seatsio 74.0.0 → 75.1.0

package/dist/src/Accounts/Account.d.ts

@@ -0,0 +1,10 @@
+export declare class Account {
+    company: any;
+    designerKey: any;
+    email: any;
+    publicKey: any;
+    role: any;
+    secretKey: any;
+    settings: any;
+    constructor(account: any);
+}

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.d.ts

@@ -0,0 +1,8 @@
+export declare class AccountSettings {
+    chartValidation: any;
+    defaultRendererSettings: any;
+    draftChartDrawingsEnabled: any;
+    holdOnSelectForGAs: any;
+    holdPeriodInMinutes: any;
+    constructor(settings: any);
+}

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.d.ts

@@ -0,0 +1,12 @@
+export declare class Accounts {
+    private client;
+    constructor(client: any);
+    retrieveMyAccount(): any;
+    regenerateSecretKey(): any;
+    regenerateDesignerKey(): any;
+    enableDraftChartDrawings(): any;
+    disableDraftChartDrawings(): any;
+    changePassword(password: any): any;
+    changeHoldPeriod(holdPeriodInMinutes: any): any;
+    updateSetting(key: any, value: any): any;
+}

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.d.ts

@@ -0,0 +1,9 @@
+export declare class ChartValidationSettings {
+    VALIDATE_DUPLICATE_LABELS: any;
+    VALIDATE_EMPTY_FLOOR: any;
+    VALIDATE_FOCAL_POINT: any;
+    VALIDATE_OBJECTS_WITHOUT_CATEGORIES: any;
+    VALIDATE_OBJECT_TYPES_PER_CATEGORY: any;
+    VALIDATE_UNLABELED_OBJECTS: any;
+    constructor(chartValidations: any);
+}

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.d.ts

@@ -0,0 +1,5 @@
+export declare class DefaultRendererSettings {
+    multiSelectEnabled: any;
+    showFullScreenButton: any;
+    constructor(defaultRendererSettings: any);
+}

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.d.ts

@@ -0,0 +1,25 @@
+export declare class AsyncIterator {
+    client: any;
+    index: any;
+    items: any;
+    nextPageMustBeFetched: any;
+    nextPageStartsAfter: any;
+    objType: any;
+    pages: any;
+    params: any;
+    url: any;
+    constructor(url: any, client: any, objType: any, params?: {});
+    charts(data: any): void;
+    events(data: any): void;
+    seasons(data: any): void;
+    statusChanges(data: any): void;
+    subaccounts(data: any): void;
+    workspaces(data: any): void;
+    users(data: any): void;
+    fetch(fetchParams?: {}): any;
+    [Symbol.asyncIterator](): {
+        next(): Promise<{
+            done: boolean;
+        }>;
+    };
+}

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.d.ts

@@ -0,0 +1,12 @@
+export declare class Category {
+    accessible: any;
+    color: any;
+    key: any;
+    label: any;
+    constructor(key: any, label: any, color: any, accessible?: boolean);
+    setKey(key: any): this;
+    setLabel(label: any): this;
+    setColor(color: any): this;
+    setAccessible(accessible: any): this;
+    static fromJson(json: any): Category;
+}

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.d.ts

@@ -0,0 +1,15 @@
+export declare class Chart {
+    archived: any;
+    draftVersionThumbnailUrl: any;
+    events: any;
+    id: any;
+    key: any;
+    name: any;
+    publishedVersionThumbnailUrl: any;
+    socialDistancingRulesets: any;
+    status: any;
+    tags: any;
+    validation: any;
+    constructor(chart: any);
+    static socialDistancingRulesetsFromJson(json: any): {} | undefined;
+}

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.d.ts

@@ -0,0 +1,20 @@
+export declare class ChartListParams {
+    eventsLimit: any;
+    expand: any;
+    filter: any;
+    tag: any;
+    validation: any;
+    constructor(filter?: null, tag?: null, expandEvents?: null, withValidation?: boolean, eventsLimit?: null);
+    withFilter(filter: any): this;
+    withTag(tag: any): this;
+    withExpandEvents(expandEvents: any): this;
+    withEventsLimit(eventsLimit: any): this;
+    withValidation(validation: any): this;
+    serialize(): {
+        tag: any;
+        expand: any;
+        filter: any;
+        validation: any;
+        eventsLimit: any;
+    };
+}

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.d.ts

@@ -0,0 +1,17 @@
+export declare class ChartObjectInfo {
+    bookAsAWhole: any;
+    capacity: any;
+    categoryKey: any;
+    categoryLabel: any;
+    distanceToFocalPoint: any;
+    entrance: any;
+    ids: any;
+    label: any;
+    labels: any;
+    leftNeighbour: any;
+    numSeats: any;
+    objectType: any;
+    rightNeighbour: any;
+    section: any;
+    constructor(chartReport: any);
+}

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.d.ts

@@ -0,0 +1,5 @@
+export declare class ChartValidation {
+    errors: any;
+    warnings: any;
+    constructor(validation: any);
+}

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.d.ts

@@ -0,0 +1,36 @@
+import { Lister } from '../Lister';
+export declare class Charts {
+    archive: any;
+    client: any;
+    constructor(client: any);
+    create(name?: null, venueType?: null, categories?: null): any;
+    update(key: any, name?: null, categories?: null): any;
+    addCategory(key: any, category: any): any;
+    removeCategory(chartKey: any, categoryKey: any): any;
+    listCategories(key: any): any;
+    validatePublishedVersion(key: any): any;
+    validateDraftVersion(key: any): any;
+    retrieve(key: any): any;
+    retrieveWithEvents(key: any): any;
+    retrievePublishedVersion(key: any): any;
+    retrieveDraftVersion(key: any): any;
+    publishDraftVersion(key: any): any;
+    discardDraftVersion(key: any): any;
+    moveToArchive(key: any): any;
+    moveOutOfArchive(key: any): any;
+    copy(key: any): any;
+    copyDraftVersion(key: any): any;
+    copyToSubaccount(key: any, subaccountId: any): any;
+    copyToWorkspace(key: any, workspaceKey: any): any;
+    saveSocialDistancingRulesets(key: any, socialDistancingRulesets: any): any;
+    retrievePublishedVersionThumbnail(key: any): any;
+    retrieveDraftVersionThumbnail(key: any): any;
+    listAllTags(): any;
+    addTag(key: any, tag: any): any;
+    removeTag(key: any, tag: any): any;
+    listAll(requestParameters?: {}): import("../AsyncIterator").AsyncIterator;
+    listFirstPage(chartListParams?: null, pageSize?: null): any;
+    listPageAfter(afterId: any, chartListParameters?: null, pageSize?: null): any;
+    listPageBefore(beforeId: any, chartListParameters?: null, pageSize?: null): any;
+    iterator(): Lister;
+}