seatsio 74.0.0 → 75.0.0

package/dist/src/Accounts/Account.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+var AccountSettings_1 = require("./AccountSettings");
+var Account = /** @class */ (function () {
+    function Account(account) {
+        this.secretKey = account.secretKey;
+        this.designerKey = account.designerKey;
+        this.publicKey = account.publicKey;
+        this.settings = new AccountSettings_1.AccountSettings(account.settings);
+        this.company = account.company;
+        this.email = account.email;
+        this.role = account.role;
+    }
+    return Account;
+}());
+exports.Account = Account;

package/dist/src/Accounts/AccountSettings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountSettings = void 0;
+var ChartValidationSettings_1 = require("./ChartValidationSettings");
+var DefaultRendererSettings_1 = require("./DefaultRendererSettings");
+var AccountSettings = /** @class */ (function () {
+    function AccountSettings(settings) {
+        this.draftChartDrawingsEnabled = settings.draftChartDrawingsEnabled;
+        this.holdOnSelectForGAs = settings.holdOnSelectForGAs;
+        this.holdPeriodInMinutes = settings.holdPeriodInMinutes;
+        this.chartValidation = new ChartValidationSettings_1.ChartValidationSettings(settings.chartValidation);
+        this.defaultRendererSettings = new DefaultRendererSettings_1.DefaultRendererSettings(settings.defaultRendererSettings);
+    }
+    return AccountSettings;
+}());
+exports.AccountSettings = AccountSettings;

package/dist/src/Accounts/Accounts.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accounts = void 0;
+var Account_1 = require("./Account");
+var baseUrl = '/accounts/me';
+var Accounts = /** @class */ (function () {
+    function Accounts(client) {
+        this.client = client;
+    }
+    Accounts.prototype.retrieveMyAccount = function () {
+        return this.client.get(baseUrl).then(function (res) { return new Account_1.Account(res.data); });
+    };
+    Accounts.prototype.regenerateSecretKey = function () {
+        return this.client.post(baseUrl + '/secret-key/actions/regenerate').then(function (res) { return res.data.secretKey; });
+    };
+    Accounts.prototype.regenerateDesignerKey = function () {
+        return this.client.post(baseUrl + '/designer-key/actions/regenerate').then(function (res) { return res.data.designerKey; });
+    };
+    Accounts.prototype.enableDraftChartDrawings = function () {
+        return this.client.post(baseUrl + '/draft-chart-drawings/actions/enable');
+    };
+    Accounts.prototype.disableDraftChartDrawings = function () {
+        return this.client.post(baseUrl + '/draft-chart-drawings/actions/disable');
+    };
+    Accounts.prototype.changePassword = function (password) {
+        return this.client.post(baseUrl + '/actions/change-password', { password: password });
+    };
+    Accounts.prototype.changeHoldPeriod = function (holdPeriodInMinutes) {
+        return this.client.post(baseUrl + '/actions/change-hold-period', { holdPeriodInMinutes: holdPeriodInMinutes });
+    };
+    Accounts.prototype.updateSetting = function (key, value) {
+        return this.client.post(baseUrl + '/settings', { key: key, value: value });
+    };
+    return Accounts;
+}());
+exports.Accounts = Accounts;

package/dist/src/Accounts/ChartValidationSettings.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartValidationSettings = void 0;
+var ChartValidationSettings = /** @class */ (function () {
+    function ChartValidationSettings(chartValidations) {
+        this.VALIDATE_DUPLICATE_LABELS = chartValidations.VALIDATE_DUPLICATE_LABELS;
+        this.VALIDATE_OBJECTS_WITHOUT_CATEGORIES = chartValidations.VALIDATE_OBJECTS_WITHOUT_CATEGORIES;
+        this.VALIDATE_UNLABELED_OBJECTS = chartValidations.VALIDATE_UNLABELED_OBJECTS;
+        this.VALIDATE_FOCAL_POINT = chartValidations.VALIDATE_FOCAL_POINT;
+        this.VALIDATE_OBJECT_TYPES_PER_CATEGORY = chartValidations.VALIDATE_OBJECT_TYPES_PER_CATEGORY;
+        this.VALIDATE_EMPTY_FLOOR = chartValidations.VALIDATE_EMPTY_FLOOR;
+    }
+    return ChartValidationSettings;
+}());
+exports.ChartValidationSettings = ChartValidationSettings;

package/dist/src/Accounts/DefaultRendererSettings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRendererSettings = void 0;
+var DefaultRendererSettings = /** @class */ (function () {
+    function DefaultRendererSettings(defaultRendererSettings) {
+        this.showFullScreenButton = defaultRendererSettings.showFullScreenButton;
+        this.multiSelectEnabled = defaultRendererSettings.multiSelectEnabled;
+    }
+    return DefaultRendererSettings;
+}());
+exports.DefaultRendererSettings = DefaultRendererSettings;

package/dist/src/AsyncIterator.js

@@ -0,0 +1,207 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncIterator = void 0;
+var Season_1 = require("./Seasons/Season");
+var Chart_1 = require("./Charts/Chart");
+var Page_1 = require("./Page");
+var EventDeserializer_1 = require("./Events/EventDeserializer");
+var StatusChange_1 = require("./Events/StatusChange");
+var Subaccount_1 = require("./Subaccounts/Subaccount");
+var Workspace_1 = require("./Workspaces/Workspace");
+var User_1 = require("./Users/User");
+var AsyncIterator = /** @class */ (function () {
+    function AsyncIterator(url, client, objType, params) {
+        if (params === void 0) { params = {}; }
+        this.url = url;
+        this.client = client;
+        this.objType = objType;
+        this.params = params;
+        this.items = [];
+        this.pages = [];
+        this.index = 0;
+        this.nextPageMustBeFetched = true;
+    }
+    AsyncIterator.prototype.charts = function (data) {
+        var _this_1 = this;
+        var charts = [];
+        data.items.forEach(function (chartData) {
+            var chart = new Chart_1.Chart(chartData);
+            _this_1.items.push(chart);
+            charts.push(chart);
+        });
+        this.pages.push(new Page_1.Page(charts, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.events = function (data) {
+        var _this_1 = this;
+        var events = [];
+        data.items.forEach(function (eventData) {
+            var event = new EventDeserializer_1.EventDeserializer().fromJson(eventData);
+            _this_1.items.push(event);
+            events.push(event);
+        });
+        this.pages.push(new Page_1.Page(events, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.seasons = function (data) {
+        var _this_1 = this;
+        var seasons = [];
+        data.items.forEach(function (seasonData) {
+            var season = new Season_1.Season(seasonData);
+            _this_1.items.push(season);
+            seasons.push(season);
+        });
+        this.pages.push(new Page_1.Page(seasons, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.statusChanges = function (data) {
+        var _this_1 = this;
+        var statusChanges = [];
+        data.items.forEach(function (statusData) {
+            var status = new StatusChange_1.StatusChange(statusData);
+            _this_1.items.push(status);
+            statusChanges.push(status);
+        });
+        this.pages.push(new Page_1.Page(statusChanges, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.subaccounts = function (data) {
+        var _this_1 = this;
+        var subaccounts = [];
+        data.items.forEach(function (subaccountData) {
+            var subaccount = new Subaccount_1.Subaccount(subaccountData);
+            _this_1.items.push(subaccount);
+            subaccounts.push(subaccount);
+        });
+        this.pages.push(new Page_1.Page(subaccounts, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.workspaces = function (data) {
+        var _this_1 = this;
+        var workspaces = [];
+        data.items.forEach(function (json) {
+            var workspace = new Workspace_1.Workspace(json);
+            _this_1.items.push(workspace);
+            workspaces.push(workspace);
+        });
+        this.pages.push(new Page_1.Page(workspaces, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.users = function (data) {
+        var _this_1 = this;
+        var users = [];
+        data.items.forEach(function (userData) {
+            var user = new User_1.User(userData);
+            _this_1.items.push(user);
+            users.push(user);
+        });
+        this.pages.push(new Page_1.Page(users, data.next_page_starts_after, data.previous_page_ends_before));
+    };
+    AsyncIterator.prototype.fetch = function (fetchParams) {
+        var _this_1 = this;
+        if (fetchParams === void 0) { fetchParams = {}; }
+        return this.client.get(this.url, { params: fetchParams })
+            .then(function (res) {
+            if (res.data.next_page_starts_after) {
+                _this_1.nextPageStartsAfter = res.data.next_page_starts_after;
+                _this_1.nextPageMustBeFetched = true;
+            }
+            else {
+                _this_1.nextPageMustBeFetched = false;
+            }
+            switch (_this_1.objType) {
+                case 'charts':
+                    _this_1.charts(res.data);
+                    break;
+                case 'events':
+                    _this_1.events(res.data);
+                    break;
+                case 'seasons':
+                    _this_1.seasons(res.data);
+                    break;
+                case 'statusChanges':
+                    _this_1.statusChanges(res.data);
+                    break;
+                case 'subaccounts':
+                    _this_1.subaccounts(res.data);
+                    break;
+                case 'users':
+                    _this_1.users(res.data);
+                    break;
+                case 'workspaces':
+                    _this_1.workspaces(res.data);
+                    break;
+                default:
+                    throw new Error("Unknown object type '".concat(_this_1.objType, "'"));
+            }
+        });
+    };
+    AsyncIterator.prototype[Symbol.asyncIterator] = function () {
+        var _this = this;
+        return {
+            next: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!(_this.nextPageMustBeFetched && _this.items.length === 0)) return [3 /*break*/, 2];
+                                return [4 /*yield*/, _this.fetch(_this.params)];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 4];
+                            case 2:
+                                if (!(_this.nextPageMustBeFetched && !_this.items[_this.index])) return [3 /*break*/, 4];
+                                _this.params.start_after_id = _this.nextPageStartsAfter;
+                                return [4 /*yield*/, _this.fetch(_this.params)];
+                            case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4:
+                                if (!_this.items[_this.index]) {
+                                    return [2 /*return*/, Promise.resolve({
+                                            done: true
+                                        })];
+                                }
+                                else {
+                                    return [2 /*return*/, Promise.resolve({ value: _this.items[_this.index++], done: false })];
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+        };
+    };
+    return AsyncIterator;
+}());
+exports.AsyncIterator = AsyncIterator;

package/dist/src/Charts/Category.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Category = void 0;
+var Category = /** @class */ (function () {
+    function Category(key, label, color, accessible) {
+        if (accessible === void 0) { accessible = false; }
+        this.key = key;
+        this.label = label;
+        this.color = color;
+        this.accessible = accessible;
+    }
+    Category.prototype.setKey = function (key) {
+        this.key = key;
+        return this;
+    };
+    Category.prototype.setLabel = function (label) {
+        this.label = label;
+        return this;
+    };
+    Category.prototype.setColor = function (color) {
+        this.color = color;
+        return this;
+    };
+    Category.prototype.setAccessible = function (accessible) {
+        this.accessible = accessible;
+        return this;
+    };
+    Category.fromJson = function (json) {
+        return new Category(json.key, json.label, json.color, json.accessible);
+    };
+    return Category;
+}());
+exports.Category = Category;

package/dist/src/Charts/Chart.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chart = void 0;
+var EventDeserializer_1 = require("../Events/EventDeserializer");
+var ChartValidation_1 = require("./ChartValidation");
+var SocialDistancingRuleset_1 = require("./SocialDistancingRuleset");
+var Chart = /** @class */ (function () {
+    function Chart(chart) {
+        this.name = chart.name;
+        this.id = chart.id;
+        this.key = chart.key;
+        this.status = chart.status;
+        this.tags = chart.tags;
+        this.publishedVersionThumbnailUrl = chart.publishedVersionThumbnailUrl;
+        this.draftVersionThumbnailUrl = chart.draftVersionThumbnailUrl || null;
+        this.events = chart.events ? chart.events.map(function (event) { return new EventDeserializer_1.EventDeserializer().fromJson(event); }) : [];
+        this.archived = chart.archived;
+        if (chart.validation)
+            this.validation = new ChartValidation_1.ChartValidation(chart.validation);
+        this.socialDistancingRulesets = Chart.socialDistancingRulesetsFromJson(chart.socialDistancingRulesets);
+    }
+    Chart.socialDistancingRulesetsFromJson = function (json) {
+        if (json === undefined) {
+            return undefined;
+        }
+        var result = {};
+        for (var key in json) {
+            // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
+            result[key] = SocialDistancingRuleset_1.SocialDistancingRuleset.fromJson(json[key]);
+        }
+        return result;
+    };
+    return Chart;
+}());
+exports.Chart = Chart;

package/dist/src/Charts/ChartListParams.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartListParams = void 0;
+var ChartListParams = /** @class */ (function () {
+    function ChartListParams(filter, tag, expandEvents, withValidation, eventsLimit) {
+        if (filter === void 0) { filter = null; }
+        if (tag === void 0) { tag = null; }
+        if (expandEvents === void 0) { expandEvents = null; }
+        if (withValidation === void 0) { withValidation = false; }
+        if (eventsLimit === void 0) { eventsLimit = null; }
+        this.filter = filter;
+        this.tag = tag;
+        this.validation = withValidation;
+        this.eventsLimit = eventsLimit;
+        if (expandEvents === true) {
+            this.expand = 'events';
+        }
+    }
+    ChartListParams.prototype.withFilter = function (filter) {
+        this.filter = filter;
+        return this;
+    };
+    ChartListParams.prototype.withTag = function (tag) {
+        this.tag = tag;
+        return this;
+    };
+    ChartListParams.prototype.withExpandEvents = function (expandEvents) {
+        if (expandEvents === true) {
+            this.expand = 'events';
+        }
+        return this;
+    };
+    ChartListParams.prototype.withEventsLimit = function (eventsLimit) {
+        this.eventsLimit = eventsLimit;
+        return this;
+    };
+    ChartListParams.prototype.withValidation = function (validation) {
+        this.validation = validation;
+        return this;
+    };
+    ChartListParams.prototype.serialize = function () {
+        return {
+            tag: this.tag,
+            expand: this.expand,
+            filter: this.filter,
+            validation: this.validation,
+            eventsLimit: this.eventsLimit
+        };
+    };
+    return ChartListParams;
+}());
+exports.ChartListParams = ChartListParams;

package/dist/src/Charts/ChartObjectInfo.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartObjectInfo = void 0;
+var helperFunctions_1 = require("../utilities/helperFunctions");
+var IDs_1 = require("../Common/IDs");
+var ChartObjectInfo = /** @class */ (function () {
+    function ChartObjectInfo(chartReport) {
+        this.label = chartReport.label;
+        this.labels = helperFunctions_1.HelperFunctions.labelCreator(chartReport);
+        this.ids = new IDs_1.IDs(chartReport.ids.own, chartReport.ids.parent, chartReport.ids.section);
+        this.categoryLabel = chartReport.categoryLabel;
+        this.categoryKey = chartReport.categoryKey;
+        this.entrance = chartReport.entrance;
+        this.objectType = chartReport.objectType;
+        this.section = chartReport.section;
+        this.capacity = chartReport.capacity;
+        this.bookAsAWhole = chartReport.bookAsAWhole;
+        this.leftNeighbour = chartReport.leftNeighbour;
+        this.rightNeighbour = chartReport.rightNeighbour;
+        this.distanceToFocalPoint = chartReport.distanceToFocalPoint;
+        this.numSeats = chartReport.numSeats;
+    }
+    return ChartObjectInfo;
+}());
+exports.ChartObjectInfo = ChartObjectInfo;

package/dist/src/Charts/ChartValidation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartValidation = void 0;
+var ChartValidation = /** @class */ (function () {
+    function ChartValidation(validation) {
+        this.errors = validation.errors;
+        this.warnings = validation.warnings;
+    }
+    return ChartValidation;
+}());
+exports.ChartValidation = ChartValidation;

package/dist/src/Charts/Charts.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Charts = void 0;
+var Lister_1 = require("../Lister");
+var Page_1 = require("../Page");
+var Chart_1 = require("./Chart");
+var Charts = /** @class */ (function () {
+    function Charts(client) {
+        this.client = client;
+        this.archive = new Lister_1.Lister('/charts/archive', this.client, 'charts', function (data) {
+            var charts = data.items.map(function (chartData) { return new Chart_1.Chart(chartData); });
+            return new Page_1.Page(charts, data.next_page_starts_after, data.previous_page_ends_before);
+        });
+    }
+    Charts.prototype.create = function (name, venueType, categories) {
+        if (name === void 0) { name = null; }
+        if (venueType === void 0) { venueType = null; }
+        if (categories === void 0) { categories = null; }
+        var requestParameters = {};
+        if (name !== null) {
+            // @ts-expect-error TS(2339): Property 'name' does not exist on type '{}'.
+            requestParameters.name = name;
+        }
+        if (venueType !== null) {
+            // @ts-expect-error TS(2339): Property 'venueType' does not exist on type '{}'.
+            requestParameters.venueType = venueType;
+        }
+        if (categories !== null) {
+            // @ts-expect-error TS(2339): Property 'categories' does not exist on type '{}'.
+            requestParameters.categories = categories;
+        }
+        return this.client.post('charts', requestParameters)
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.update = function (key, name, categories) {
+        if (name === void 0) { name = null; }
+        if (categories === void 0) { categories = null; }
+        var requestParameters = {};
+        if (name !== null) {
+            // @ts-expect-error TS(2339): Property 'name' does not exist on type '{}'.
+            requestParameters.name = name;
+        }
+        if (categories !== null) {
+            // @ts-expect-error TS(2339): Property 'categories' does not exist on type '{}'.
+            requestParameters.categories = categories;
+        }
+        return this.client.post("/charts/".concat(key), requestParameters);
+    };
+    Charts.prototype.addCategory = function (key, category) {
+        return this.client.post("/charts/".concat(key, "/categories"), category);
+    };
+    Charts.prototype.removeCategory = function (chartKey, categoryKey) {
+        return this.client.delete("/charts/".concat(chartKey, "/categories/").concat(categoryKey));
+    };
+    Charts.prototype.listCategories = function (key) {
+        return this.client.get("/charts/".concat(key, "/categories"))
+            .then(function (res) { return res.data.categories; });
+    };
+    Charts.prototype.validatePublishedVersion = function (key) {
+        return this.client.post("/charts/".concat(key, "/version/published/actions/validate"))
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.validateDraftVersion = function (key) {
+        return this.client.post("/charts/".concat(key, "/version/draft/actions/validate"))
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.retrieve = function (key) {
+        return this.client.get("charts/".concat(key))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.retrieveWithEvents = function (key) {
+        return this.client.get("charts/".concat(key, "?expand=events"))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.retrievePublishedVersion = function (key) {
+        return this.client.get("charts/".concat(key, "/version/published"))
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.retrieveDraftVersion = function (key) {
+        return this.client.get("charts/".concat(key, "/version/draft"))
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.publishDraftVersion = function (key) {
+        return this.client.post("charts/".concat(key, "/version/draft/actions/publish"));
+    };
+    Charts.prototype.discardDraftVersion = function (key) {
+        return this.client.post("/charts/".concat(key, "/version/draft/actions/discard"));
+    };
+    Charts.prototype.moveToArchive = function (key) {
+        return this.client.post("charts/".concat(key, "/actions/move-to-archive"));
+    };
+    Charts.prototype.moveOutOfArchive = function (key) {
+        return this.client.post("charts/".concat(key, "/actions/move-out-of-archive"));
+    };
+    Charts.prototype.copy = function (key) {
+        return this.client.post("charts/".concat(key, "/version/published/actions/copy"))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.copyDraftVersion = function (key) {
+        return this.client.post("charts/".concat(key, "/version/draft/actions/copy"))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.copyToSubaccount = function (key, subaccountId) {
+        return this.client.post("charts/".concat(key, "/version/published/actions/copy-to/").concat(subaccountId))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.copyToWorkspace = function (key, workspaceKey) {
+        return this.client.post("charts/".concat(key, "/version/published/actions/copy-to-workspace/").concat(workspaceKey))
+            .then(function (res) { return new Chart_1.Chart(res.data); });
+    };
+    Charts.prototype.saveSocialDistancingRulesets = function (key, socialDistancingRulesets) {
+        return this.client.post("/charts/".concat(key, "/social-distancing-rulesets"), { socialDistancingRulesets: socialDistancingRulesets });
+    };
+    Charts.prototype.retrievePublishedVersionThumbnail = function (key) {
+        return this.client.get("/charts/".concat(key, "/version/published/thumbnail"), { responseType: 'arraybuffer' })
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.retrieveDraftVersionThumbnail = function (key) {
+        return this.client.get("/charts/".concat(key, "/version/draft/thumbnail"), { responseType: 'arraybuffer' })
+            .then(function (res) { return res.data; });
+    };
+    Charts.prototype.listAllTags = function () {
+        return this.client.get('/charts/tags')
+            .then(function (res) { return res.data.tags; });
+    };
+    Charts.prototype.addTag = function (key, tag) {
+        var url = "charts/".concat(key, "/tags/").concat(encodeURIComponent(tag));
+        return this.client.post(url);
+    };
+    Charts.prototype.removeTag = function (key, tag) {
+        var url = "charts/".concat(key, "/tags/").concat(encodeURIComponent(tag));
+        return this.client.delete(url);
+    };
+    Charts.prototype.listAll = function (requestParameters) {
+        if (requestParameters === void 0) { requestParameters = {}; }
+        return this.iterator().all(requestParameters);
+    };
+    Charts.prototype.listFirstPage = function (chartListParams, pageSize) {
+        if (chartListParams === void 0) { chartListParams = null; }
+        if (pageSize === void 0) { pageSize = null; }
+        return this.iterator().firstPage(chartListParams, pageSize);
+    };
+    Charts.prototype.listPageAfter = function (afterId, chartListParameters, pageSize) {
+        if (chartListParameters === void 0) { chartListParameters = null; }
+        if (pageSize === void 0) { pageSize = null; }
+        return this.iterator().pageAfter(afterId, chartListParameters, pageSize);
+    };
+    Charts.prototype.listPageBefore = function (beforeId, chartListParameters, pageSize) {
+        if (chartListParameters === void 0) { chartListParameters = null; }
+        if (pageSize === void 0) { pageSize = null; }
+        return this.iterator().pageBefore(beforeId, chartListParameters, pageSize);
+    };
+    Charts.prototype.iterator = function () {
+        return new Lister_1.Lister('/charts', this.client, 'charts', function (data) {
+            var charts = data.items.map(function (chartData) { return new Chart_1.Chart(chartData); });
+            return new Page_1.Page(charts, data.next_page_starts_after, data.previous_page_ends_before);
+        });
+    };
+    return Charts;
+}());
+exports.Charts = Charts;