@arrowsphere/api-client 3.7.0 → 3.8.0-rc.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.8.0] - 2022-06-27
+
+### Changed
+
+- Adding 2 new EndPoints of Campaign:
+  - Get campaign assets
+  - Get active Campaign
+
 ## [3.7.0] - 2022-06-23
 
 ### Changed

package/build/campaign/campaignClient.d.ts

@@ -0,0 +1,12 @@
+import { AbstractClient, Parameters } from '../abstractClient';
+import { GetResult } from '../getResult';
+import { Campaign } from './entities/campaign/campaign';
+import { CampaignAssets } from './entities/campaignAssets/campaignAssets';
+export declare class CampaignClient extends AbstractClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    getActiveCampaign(parameters?: Parameters): Promise<GetResult<Campaign>>;
+    getCampaignAssets(campaignReference: string, parameters?: Parameters): Promise<GetResult<CampaignAssets>>;
+}

package/build/campaign/campaignClient.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CampaignClient = void 0;
+const abstractClient_1 = require("../abstractClient");
+const getResult_1 = require("../getResult");
+const campaign_1 = require("./entities/campaign/campaign");
+const campaignAssets_1 = require("./entities/campaignAssets/campaignAssets");
+class CampaignClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/campaigns';
+    }
+    async getActiveCampaign(parameters = {}) {
+        this.path = '/active';
+        return new getResult_1.GetResult(campaign_1.Campaign, await this.get(parameters));
+    }
+    async getCampaignAssets(campaignReference, parameters = {}) {
+        this.path = `/${campaignReference}/assets`;
+        return new getResult_1.GetResult(campaignAssets_1.CampaignAssets, await this.get(parameters));
+    }
+}
+exports.CampaignClient = CampaignClient;
+//# sourceMappingURL=campaignClient.js.map

package/build/campaign/entities/campaign/banners/banners.d.ts

@@ -0,0 +1,28 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum BannersFields {
+    COLUMN_BACKGROUND_IMAGE_UUID = "backgroundImageUuid",
+    COLUMN_TYPE = "type",
+    COLUMN_BUTTON_PLACEMENT = "buttonPlacement",
+    COLUMN_BUTTON_TEXT = "buttonText",
+    COLUMN_TEXT = "text",
+    COLUMN_TEXT_COLOR = "textColor"
+}
+export declare type BannersType = {
+    [BannersFields.COLUMN_BACKGROUND_IMAGE_UUID]: string;
+    [BannersFields.COLUMN_TYPE]?: string;
+    [BannersFields.COLUMN_BUTTON_PLACEMENT]?: string;
+    [BannersFields.COLUMN_BUTTON_TEXT]?: string;
+    [BannersFields.COLUMN_TEXT]?: string;
+    [BannersFields.COLUMN_TEXT_COLOR]?: string;
+};
+export declare class Banners extends AbstractEntity<BannersType> {
+    #private;
+    constructor(bannerInput: BannersType);
+    get backgroundImageUuid(): string;
+    get type(): string | undefined;
+    get buttonPlacement(): string | undefined;
+    get buttonText(): string | undefined;
+    get text(): string | undefined;
+    get textColor(): string | undefined;
+    toJSON(): BannersType;
+}

package/build/campaign/entities/campaign/banners/banners.js

@@ -0,0 +1,75 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _backgroundImageUuid, _type, _buttonPlacement, _buttonText, _text, _textColor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Banners = exports.BannersFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var BannersFields;
+(function (BannersFields) {
+    BannersFields["COLUMN_BACKGROUND_IMAGE_UUID"] = "backgroundImageUuid";
+    BannersFields["COLUMN_TYPE"] = "type";
+    BannersFields["COLUMN_BUTTON_PLACEMENT"] = "buttonPlacement";
+    BannersFields["COLUMN_BUTTON_TEXT"] = "buttonText";
+    BannersFields["COLUMN_TEXT"] = "text";
+    BannersFields["COLUMN_TEXT_COLOR"] = "textColor";
+})(BannersFields = exports.BannersFields || (exports.BannersFields = {}));
+class Banners extends abstractEntity_1.AbstractEntity {
+    constructor(bannerInput) {
+        super(bannerInput);
+        _backgroundImageUuid.set(this, void 0);
+        _type.set(this, void 0);
+        _buttonPlacement.set(this, void 0);
+        _buttonText.set(this, void 0);
+        _text.set(this, void 0);
+        _textColor.set(this, void 0);
+        __classPrivateFieldSet(this, _backgroundImageUuid, bannerInput[BannersFields.COLUMN_BACKGROUND_IMAGE_UUID]);
+        __classPrivateFieldSet(this, _type, bannerInput[BannersFields.COLUMN_TYPE]);
+        __classPrivateFieldSet(this, _buttonPlacement, bannerInput[BannersFields.COLUMN_BUTTON_PLACEMENT]);
+        __classPrivateFieldSet(this, _buttonText, bannerInput[BannersFields.COLUMN_BUTTON_TEXT]);
+        __classPrivateFieldSet(this, _text, bannerInput[BannersFields.COLUMN_TEXT]);
+        __classPrivateFieldSet(this, _textColor, bannerInput[BannersFields.COLUMN_TEXT_COLOR]);
+    }
+    get backgroundImageUuid() {
+        return __classPrivateFieldGet(this, _backgroundImageUuid);
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _type);
+    }
+    get buttonPlacement() {
+        return __classPrivateFieldGet(this, _buttonPlacement);
+    }
+    get buttonText() {
+        return __classPrivateFieldGet(this, _buttonText);
+    }
+    get text() {
+        return __classPrivateFieldGet(this, _text);
+    }
+    get textColor() {
+        return __classPrivateFieldGet(this, _textColor);
+    }
+    toJSON() {
+        return {
+            [BannersFields.COLUMN_BACKGROUND_IMAGE_UUID]: this.backgroundImageUuid,
+            [BannersFields.COLUMN_TYPE]: this.type,
+            [BannersFields.COLUMN_BUTTON_PLACEMENT]: this.buttonPlacement,
+            [BannersFields.COLUMN_BUTTON_TEXT]: this.buttonText,
+            [BannersFields.COLUMN_TEXT]: this.text,
+            [BannersFields.COLUMN_TEXT_COLOR]: this.textColor,
+        };
+    }
+}
+exports.Banners = Banners;
+_backgroundImageUuid = new WeakMap(), _type = new WeakMap(), _buttonPlacement = new WeakMap(), _buttonText = new WeakMap(), _text = new WeakMap(), _textColor = new WeakMap();
+//# sourceMappingURL=banners.js.map

package/build/campaign/entities/campaign/campaign.d.ts

@@ -0,0 +1,52 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Banners, BannersType } from './banners/banners';
+import { LandingPage, LandingPageType } from './landingPage/landingPage';
+import { Rules, RulesType } from './rules/rules';
+export declare enum CampaignFields {
+    COLUMN_REFERENCE = "reference",
+    COLUMN_NAME = "name",
+    COLUMN_CATEGORY = "category",
+    COLUMN_IS_ACTIVATED = "isActivated",
+    COLUMN_CREATED_AT = "createdAt",
+    COLUMN_UPDATED_AT = "updatedAt",
+    COLUMN_DELETED_AT = "deletedAt",
+    COLUMN_RULES = "rules",
+    COLUMN_WEIGHT = "weight",
+    COLUMN_START_DATE = "startDate",
+    COLUMN_END_DATE = "endDate",
+    COLUMN_BANNERS = "banners",
+    COLUMN_LANDING_PAGE = "landingPage"
+}
+export declare type CampaignType = {
+    [CampaignFields.COLUMN_REFERENCE]: string;
+    [CampaignFields.COLUMN_NAME]: string;
+    [CampaignFields.COLUMN_CATEGORY]?: string;
+    [CampaignFields.COLUMN_IS_ACTIVATED]?: boolean;
+    [CampaignFields.COLUMN_CREATED_AT]: string;
+    [CampaignFields.COLUMN_UPDATED_AT]: string;
+    [CampaignFields.COLUMN_DELETED_AT]?: string;
+    [CampaignFields.COLUMN_RULES]?: RulesType;
+    [CampaignFields.COLUMN_WEIGHT]?: number;
+    [CampaignFields.COLUMN_START_DATE]?: string;
+    [CampaignFields.COLUMN_END_DATE]?: string;
+    [CampaignFields.COLUMN_BANNERS]: BannersType[];
+    [CampaignFields.COLUMN_LANDING_PAGE]: LandingPageType;
+};
+export declare class Campaign extends AbstractEntity<CampaignType> {
+    #private;
+    constructor(campaignInput: CampaignType);
+    get reference(): string;
+    get name(): string;
+    get category(): string | undefined;
+    get isActivated(): boolean | undefined;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deletedAt(): string | undefined;
+    get rules(): Rules | undefined;
+    get weight(): number | undefined;
+    get startDate(): string | undefined;
+    get endDate(): string | undefined;
+    get banners(): Banners[];
+    get landingPage(): LandingPage;
+    toJSON(): CampaignType;
+}

package/build/campaign/entities/campaign/campaign.js

@@ -0,0 +1,130 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _reference, _name, _category, _isActivated, _createdAt, _updatedAt, _deletedAt, _rules, _weight, _startDate, _endDate, _banners, _landingPage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Campaign = exports.CampaignFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const banners_1 = require("./banners/banners");
+const landingPage_1 = require("./landingPage/landingPage");
+const rules_1 = require("./rules/rules");
+var CampaignFields;
+(function (CampaignFields) {
+    CampaignFields["COLUMN_REFERENCE"] = "reference";
+    CampaignFields["COLUMN_NAME"] = "name";
+    CampaignFields["COLUMN_CATEGORY"] = "category";
+    CampaignFields["COLUMN_IS_ACTIVATED"] = "isActivated";
+    CampaignFields["COLUMN_CREATED_AT"] = "createdAt";
+    CampaignFields["COLUMN_UPDATED_AT"] = "updatedAt";
+    CampaignFields["COLUMN_DELETED_AT"] = "deletedAt";
+    CampaignFields["COLUMN_RULES"] = "rules";
+    CampaignFields["COLUMN_WEIGHT"] = "weight";
+    CampaignFields["COLUMN_START_DATE"] = "startDate";
+    CampaignFields["COLUMN_END_DATE"] = "endDate";
+    CampaignFields["COLUMN_BANNERS"] = "banners";
+    CampaignFields["COLUMN_LANDING_PAGE"] = "landingPage";
+})(CampaignFields = exports.CampaignFields || (exports.CampaignFields = {}));
+class Campaign extends abstractEntity_1.AbstractEntity {
+    constructor(campaignInput) {
+        super(campaignInput);
+        _reference.set(this, void 0);
+        _name.set(this, void 0);
+        _category.set(this, void 0);
+        _isActivated.set(this, void 0);
+        _createdAt.set(this, void 0);
+        _updatedAt.set(this, void 0);
+        _deletedAt.set(this, void 0);
+        _rules.set(this, void 0);
+        _weight.set(this, void 0);
+        _startDate.set(this, void 0);
+        _endDate.set(this, void 0);
+        _banners.set(this, void 0);
+        _landingPage.set(this, void 0);
+        __classPrivateFieldSet(this, _reference, campaignInput[CampaignFields.COLUMN_REFERENCE]);
+        __classPrivateFieldSet(this, _name, campaignInput[CampaignFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _category, campaignInput[CampaignFields.COLUMN_CATEGORY]);
+        __classPrivateFieldSet(this, _isActivated, campaignInput[CampaignFields.COLUMN_IS_ACTIVATED]);
+        __classPrivateFieldSet(this, _createdAt, campaignInput[CampaignFields.COLUMN_CREATED_AT]);
+        __classPrivateFieldSet(this, _updatedAt, campaignInput[CampaignFields.COLUMN_UPDATED_AT]);
+        __classPrivateFieldSet(this, _deletedAt, campaignInput[CampaignFields.COLUMN_DELETED_AT]);
+        __classPrivateFieldSet(this, _rules, campaignInput[CampaignFields.COLUMN_RULES]
+            ? new rules_1.Rules(campaignInput[CampaignFields.COLUMN_RULES])
+            : undefined);
+        __classPrivateFieldSet(this, _weight, campaignInput[CampaignFields.COLUMN_WEIGHT]);
+        __classPrivateFieldSet(this, _startDate, campaignInput[CampaignFields.COLUMN_START_DATE]);
+        __classPrivateFieldSet(this, _endDate, campaignInput[CampaignFields.COLUMN_END_DATE]);
+        __classPrivateFieldSet(this, _banners, campaignInput[CampaignFields.COLUMN_BANNERS].map((banner) => new banners_1.Banners(banner)));
+        __classPrivateFieldSet(this, _landingPage, new landingPage_1.LandingPage(campaignInput[CampaignFields.COLUMN_LANDING_PAGE]));
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get category() {
+        return __classPrivateFieldGet(this, _category);
+    }
+    get isActivated() {
+        return __classPrivateFieldGet(this, _isActivated);
+    }
+    get createdAt() {
+        return __classPrivateFieldGet(this, _createdAt);
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _updatedAt);
+    }
+    get deletedAt() {
+        return __classPrivateFieldGet(this, _deletedAt);
+    }
+    get rules() {
+        return __classPrivateFieldGet(this, _rules);
+    }
+    get weight() {
+        return __classPrivateFieldGet(this, _weight);
+    }
+    get startDate() {
+        return __classPrivateFieldGet(this, _startDate);
+    }
+    get endDate() {
+        return __classPrivateFieldGet(this, _endDate);
+    }
+    get banners() {
+        return __classPrivateFieldGet(this, _banners);
+    }
+    get landingPage() {
+        return __classPrivateFieldGet(this, _landingPage);
+    }
+    toJSON() {
+        var _a;
+        return {
+            [CampaignFields.COLUMN_REFERENCE]: this.reference,
+            [CampaignFields.COLUMN_NAME]: this.name,
+            [CampaignFields.COLUMN_CATEGORY]: this.category,
+            [CampaignFields.COLUMN_IS_ACTIVATED]: this.isActivated,
+            [CampaignFields.COLUMN_CREATED_AT]: this.createdAt,
+            [CampaignFields.COLUMN_UPDATED_AT]: this.updatedAt,
+            [CampaignFields.COLUMN_DELETED_AT]: this.deletedAt,
+            [CampaignFields.COLUMN_RULES]: (_a = this.rules) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            [CampaignFields.COLUMN_WEIGHT]: this.weight,
+            [CampaignFields.COLUMN_START_DATE]: this.startDate,
+            [CampaignFields.COLUMN_END_DATE]: this.endDate,
+            [CampaignFields.COLUMN_BANNERS]: this.banners.map((banner) => banner.toJSON()),
+            [CampaignFields.COLUMN_LANDING_PAGE]: this.landingPage.toJSON(),
+        };
+    }
+}
+exports.Campaign = Campaign;
+_reference = new WeakMap(), _name = new WeakMap(), _category = new WeakMap(), _isActivated = new WeakMap(), _createdAt = new WeakMap(), _updatedAt = new WeakMap(), _deletedAt = new WeakMap(), _rules = new WeakMap(), _weight = new WeakMap(), _startDate = new WeakMap(), _endDate = new WeakMap(), _banners = new WeakMap(), _landingPage = new WeakMap();
+//# sourceMappingURL=campaign.js.map

package/build/campaign/entities/campaign/landingPage/landingPage.d.ts

@@ -0,0 +1,25 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { LandingPageBody, LandingPageBodyType } from './landingPageBody';
+import { LandingPageFooter, LandingPageFooterType } from './landingPageFooter/landingPageFooter';
+import { LandingPageHeader, LandingPageHeaderType } from './landingPageHeader';
+export declare enum LandingPageFields {
+    COLUMN_URL = "url",
+    COLUMN_HEADER = "header",
+    COLUMN_BODY = "body",
+    COLUMN_FOOTER = "footer"
+}
+export declare type LandingPageType = {
+    [LandingPageFields.COLUMN_URL]?: string;
+    [LandingPageFields.COLUMN_HEADER]: LandingPageHeaderType;
+    [LandingPageFields.COLUMN_BODY]: LandingPageBodyType;
+    [LandingPageFields.COLUMN_FOOTER]?: LandingPageFooterType;
+};
+export declare class LandingPage extends AbstractEntity<LandingPageType> {
+    #private;
+    constructor(landingPageInput: LandingPageType);
+    get url(): string | undefined;
+    get header(): LandingPageHeader;
+    get body(): LandingPageBody;
+    get footer(): LandingPageFooter | undefined;
+    toJSON(): LandingPageType;
+}

package/build/campaign/entities/campaign/landingPage/landingPage.js

@@ -0,0 +1,67 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _url, _header, _body, _footer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandingPage = exports.LandingPageFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+const landingPageBody_1 = require("./landingPageBody");
+const landingPageFooter_1 = require("./landingPageFooter/landingPageFooter");
+const landingPageHeader_1 = require("./landingPageHeader");
+var LandingPageFields;
+(function (LandingPageFields) {
+    LandingPageFields["COLUMN_URL"] = "url";
+    LandingPageFields["COLUMN_HEADER"] = "header";
+    LandingPageFields["COLUMN_BODY"] = "body";
+    LandingPageFields["COLUMN_FOOTER"] = "footer";
+})(LandingPageFields = exports.LandingPageFields || (exports.LandingPageFields = {}));
+class LandingPage extends abstractEntity_1.AbstractEntity {
+    constructor(landingPageInput) {
+        super(landingPageInput);
+        _url.set(this, void 0);
+        _header.set(this, void 0);
+        _body.set(this, void 0);
+        _footer.set(this, void 0);
+        __classPrivateFieldSet(this, _url, landingPageInput[LandingPageFields.COLUMN_URL]);
+        __classPrivateFieldSet(this, _header, new landingPageHeader_1.LandingPageHeader(landingPageInput[LandingPageFields.COLUMN_HEADER]));
+        __classPrivateFieldSet(this, _body, new landingPageBody_1.LandingPageBody(landingPageInput[LandingPageFields.COLUMN_BODY]));
+        __classPrivateFieldSet(this, _footer, landingPageInput[LandingPageFields.COLUMN_FOOTER]
+            ? new landingPageFooter_1.LandingPageFooter(landingPageInput[LandingPageFields.COLUMN_FOOTER])
+            : undefined);
+    }
+    get url() {
+        return __classPrivateFieldGet(this, _url);
+    }
+    get header() {
+        return __classPrivateFieldGet(this, _header);
+    }
+    get body() {
+        return __classPrivateFieldGet(this, _body);
+    }
+    get footer() {
+        return __classPrivateFieldGet(this, _footer);
+    }
+    toJSON() {
+        var _a;
+        return {
+            [LandingPageFields.COLUMN_URL]: this.url,
+            [LandingPageFields.COLUMN_HEADER]: this.header.toJSON(),
+            [LandingPageFields.COLUMN_BODY]: this.body.toJSON(),
+            [LandingPageFields.COLUMN_FOOTER]: (_a = this.footer) === null || _a === void 0 ? void 0 : _a.toJSON(),
+        };
+    }
+}
+exports.LandingPage = LandingPage;
+_url = new WeakMap(), _header = new WeakMap(), _body = new WeakMap(), _footer = new WeakMap();
+//# sourceMappingURL=landingPage.js.map

package/build/campaign/entities/campaign/landingPage/landingPageBody.d.ts

@@ -0,0 +1,34 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum LandingPageBodyFields {
+    COLUMN_BACKGROUND_IMAGE_UUID = "backgroundImageUuid",
+    COLUMN_BACKGROUND_COLOR = "backgroundColor",
+    COLUMN_TYPE = "type",
+    COLUMN_TITLE = "title",
+    COLUMN_DESCRIPTION = "description",
+    COLUMN_VIDEO_URL = "videoUrl",
+    COLUMN_BUTTON_TEXT = "buttonText",
+    COLUMN_CONTACT_EMAIL = "contactEmail"
+}
+export declare type LandingPageBodyType = {
+    [LandingPageBodyFields.COLUMN_BACKGROUND_IMAGE_UUID]: string;
+    [LandingPageBodyFields.COLUMN_BACKGROUND_COLOR]?: string;
+    [LandingPageBodyFields.COLUMN_TYPE]?: string;
+    [LandingPageBodyFields.COLUMN_TITLE]?: string;
+    [LandingPageBodyFields.COLUMN_DESCRIPTION]?: string;
+    [LandingPageBodyFields.COLUMN_VIDEO_URL]?: string;
+    [LandingPageBodyFields.COLUMN_BUTTON_TEXT]?: string;
+    [LandingPageBodyFields.COLUMN_CONTACT_EMAIL]?: string;
+};
+export declare class LandingPageBody extends AbstractEntity<LandingPageBodyType> {
+    #private;
+    constructor(landingPageBodyInput: LandingPageBodyType);
+    get backgroundImageUuid(): string;
+    get backgroundColor(): string | undefined;
+    get type(): string | undefined;
+    get title(): string | undefined;
+    get description(): string | undefined;
+    get videoUrl(): string | undefined;
+    get buttonText(): string | undefined;
+    get contactEmail(): string | undefined;
+    toJSON(): LandingPageBodyType;
+}

package/build/campaign/entities/campaign/landingPage/landingPageBody.js

@@ -0,0 +1,90 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _backgroundImageUuid, _backgroundColor, _type, _title, _description, _videoUrl, _buttonText, _contactEmail;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandingPageBody = exports.LandingPageBodyFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var LandingPageBodyFields;
+(function (LandingPageBodyFields) {
+    LandingPageBodyFields["COLUMN_BACKGROUND_IMAGE_UUID"] = "backgroundImageUuid";
+    LandingPageBodyFields["COLUMN_BACKGROUND_COLOR"] = "backgroundColor";
+    LandingPageBodyFields["COLUMN_TYPE"] = "type";
+    LandingPageBodyFields["COLUMN_TITLE"] = "title";
+    LandingPageBodyFields["COLUMN_DESCRIPTION"] = "description";
+    LandingPageBodyFields["COLUMN_VIDEO_URL"] = "videoUrl";
+    LandingPageBodyFields["COLUMN_BUTTON_TEXT"] = "buttonText";
+    LandingPageBodyFields["COLUMN_CONTACT_EMAIL"] = "contactEmail";
+})(LandingPageBodyFields = exports.LandingPageBodyFields || (exports.LandingPageBodyFields = {}));
+class LandingPageBody extends abstractEntity_1.AbstractEntity {
+    constructor(landingPageBodyInput) {
+        super(landingPageBodyInput);
+        _backgroundImageUuid.set(this, void 0);
+        _backgroundColor.set(this, void 0);
+        _type.set(this, void 0);
+        _title.set(this, void 0);
+        _description.set(this, void 0);
+        _videoUrl.set(this, void 0);
+        _buttonText.set(this, void 0);
+        _contactEmail.set(this, void 0);
+        __classPrivateFieldSet(this, _backgroundImageUuid, landingPageBodyInput[LandingPageBodyFields.COLUMN_BACKGROUND_IMAGE_UUID]);
+        __classPrivateFieldSet(this, _backgroundColor, landingPageBodyInput[LandingPageBodyFields.COLUMN_BACKGROUND_COLOR]);
+        __classPrivateFieldSet(this, _type, landingPageBodyInput[LandingPageBodyFields.COLUMN_TYPE]);
+        __classPrivateFieldSet(this, _title, landingPageBodyInput[LandingPageBodyFields.COLUMN_TITLE]);
+        __classPrivateFieldSet(this, _description, landingPageBodyInput[LandingPageBodyFields.COLUMN_DESCRIPTION]);
+        __classPrivateFieldSet(this, _videoUrl, landingPageBodyInput[LandingPageBodyFields.COLUMN_VIDEO_URL]);
+        __classPrivateFieldSet(this, _buttonText, landingPageBodyInput[LandingPageBodyFields.COLUMN_BUTTON_TEXT]);
+        __classPrivateFieldSet(this, _contactEmail, landingPageBodyInput[LandingPageBodyFields.COLUMN_CONTACT_EMAIL]);
+    }
+    get backgroundImageUuid() {
+        return __classPrivateFieldGet(this, _backgroundImageUuid);
+    }
+    get backgroundColor() {
+        return __classPrivateFieldGet(this, _backgroundColor);
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _type);
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _title);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    get videoUrl() {
+        return __classPrivateFieldGet(this, _videoUrl);
+    }
+    get buttonText() {
+        return __classPrivateFieldGet(this, _buttonText);
+    }
+    get contactEmail() {
+        return __classPrivateFieldGet(this, _contactEmail);
+    }
+    toJSON() {
+        return {
+            [LandingPageBodyFields.COLUMN_BACKGROUND_IMAGE_UUID]: this
+                .backgroundImageUuid,
+            [LandingPageBodyFields.COLUMN_BACKGROUND_COLOR]: this.backgroundColor,
+            [LandingPageBodyFields.COLUMN_TYPE]: this.type,
+            [LandingPageBodyFields.COLUMN_TITLE]: this.title,
+            [LandingPageBodyFields.COLUMN_DESCRIPTION]: this.description,
+            [LandingPageBodyFields.COLUMN_VIDEO_URL]: this.videoUrl,
+            [LandingPageBodyFields.COLUMN_BUTTON_TEXT]: this.buttonText,
+            [LandingPageBodyFields.COLUMN_CONTACT_EMAIL]: this.contactEmail,
+        };
+    }
+}
+exports.LandingPageBody = LandingPageBody;
+_backgroundImageUuid = new WeakMap(), _backgroundColor = new WeakMap(), _type = new WeakMap(), _title = new WeakMap(), _description = new WeakMap(), _videoUrl = new WeakMap(), _buttonText = new WeakMap(), _contactEmail = new WeakMap();
+//# sourceMappingURL=landingPageBody.js.map

package/build/campaign/entities/campaign/landingPage/landingPageFooter/landingPageFooter.d.ts

@@ -0,0 +1,29 @@
+import { AbstractEntity } from '../../../../../abstractEntity';
+import { LandingPageFooterFeature, LandingPageFooterFeatureType } from './landingPageFooterFeature';
+export declare enum LandingPageFooterFields {
+    COLUMN_TITLE = "title",
+    COLUMN_BACKGROUND_COLOR = "backgroundColor",
+    COLUMN_BUTTON_TEXT = "buttonText",
+    COLUMN_BUTTON_URL = "buttonUrl",
+    COLUMN_TEXT_COLOR = "textColor",
+    COLUMN_FEATURES = "features"
+}
+export declare type LandingPageFooterType = {
+    [LandingPageFooterFields.COLUMN_TITLE]?: string;
+    [LandingPageFooterFields.COLUMN_BACKGROUND_COLOR]?: string;
+    [LandingPageFooterFields.COLUMN_BUTTON_TEXT]?: string;
+    [LandingPageFooterFields.COLUMN_BUTTON_URL]?: string;
+    [LandingPageFooterFields.COLUMN_TEXT_COLOR]?: string;
+    [LandingPageFooterFields.COLUMN_FEATURES]?: Array<LandingPageFooterFeatureType>;
+};
+export declare class LandingPageFooter extends AbstractEntity<LandingPageFooterType> {
+    #private;
+    constructor(landingPageFooterInput: LandingPageFooterType);
+    get title(): string | undefined;
+    get backgroundColor(): string | undefined;
+    get buttonText(): string | undefined;
+    get buttonUrl(): string | undefined;
+    get textColor(): string | undefined;
+    get features(): Array<LandingPageFooterFeature> | undefined;
+    toJSON(): LandingPageFooterType;
+}

package/build/campaign/entities/campaign/landingPage/landingPageFooter/landingPageFooter.js

@@ -0,0 +1,78 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _title, _backgroundColor, _buttonText, _buttonUrl, _textColor, _features;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandingPageFooter = exports.LandingPageFooterFields = void 0;
+const abstractEntity_1 = require("../../../../../abstractEntity");
+const landingPageFooterFeature_1 = require("./landingPageFooterFeature");
+var LandingPageFooterFields;
+(function (LandingPageFooterFields) {
+    LandingPageFooterFields["COLUMN_TITLE"] = "title";
+    LandingPageFooterFields["COLUMN_BACKGROUND_COLOR"] = "backgroundColor";
+    LandingPageFooterFields["COLUMN_BUTTON_TEXT"] = "buttonText";
+    LandingPageFooterFields["COLUMN_BUTTON_URL"] = "buttonUrl";
+    LandingPageFooterFields["COLUMN_TEXT_COLOR"] = "textColor";
+    LandingPageFooterFields["COLUMN_FEATURES"] = "features";
+})(LandingPageFooterFields = exports.LandingPageFooterFields || (exports.LandingPageFooterFields = {}));
+class LandingPageFooter extends abstractEntity_1.AbstractEntity {
+    constructor(landingPageFooterInput) {
+        var _a;
+        super(landingPageFooterInput);
+        _title.set(this, void 0);
+        _backgroundColor.set(this, void 0);
+        _buttonText.set(this, void 0);
+        _buttonUrl.set(this, void 0);
+        _textColor.set(this, void 0);
+        _features.set(this, void 0);
+        __classPrivateFieldSet(this, _title, landingPageFooterInput[LandingPageFooterFields.COLUMN_TITLE]);
+        __classPrivateFieldSet(this, _backgroundColor, landingPageFooterInput[LandingPageFooterFields.COLUMN_BACKGROUND_COLOR]);
+        __classPrivateFieldSet(this, _buttonText, landingPageFooterInput[LandingPageFooterFields.COLUMN_BUTTON_TEXT]);
+        __classPrivateFieldSet(this, _buttonUrl, landingPageFooterInput[LandingPageFooterFields.COLUMN_BUTTON_URL]);
+        __classPrivateFieldSet(this, _textColor, landingPageFooterInput[LandingPageFooterFields.COLUMN_TEXT_COLOR]);
+        __classPrivateFieldSet(this, _features, (_a = landingPageFooterInput[LandingPageFooterFields.COLUMN_FEATURES]) === null || _a === void 0 ? void 0 : _a.map((landingPageFooterFeature) => new landingPageFooterFeature_1.LandingPageFooterFeature(landingPageFooterFeature)));
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _title);
+    }
+    get backgroundColor() {
+        return __classPrivateFieldGet(this, _backgroundColor);
+    }
+    get buttonText() {
+        return __classPrivateFieldGet(this, _buttonText);
+    }
+    get buttonUrl() {
+        return __classPrivateFieldGet(this, _buttonUrl);
+    }
+    get textColor() {
+        return __classPrivateFieldGet(this, _textColor);
+    }
+    get features() {
+        return __classPrivateFieldGet(this, _features);
+    }
+    toJSON() {
+        var _a;
+        return {
+            [LandingPageFooterFields.COLUMN_TITLE]: this.title,
+            [LandingPageFooterFields.COLUMN_BACKGROUND_COLOR]: this.backgroundColor,
+            [LandingPageFooterFields.COLUMN_BUTTON_TEXT]: this.buttonText,
+            [LandingPageFooterFields.COLUMN_BUTTON_URL]: this.buttonUrl,
+            [LandingPageFooterFields.COLUMN_TEXT_COLOR]: this.textColor,
+            [LandingPageFooterFields.COLUMN_FEATURES]: (_a = this.features) === null || _a === void 0 ? void 0 : _a.map((landingPageFooterFeature) => landingPageFooterFeature.toJSON()),
+        };
+    }
+}
+exports.LandingPageFooter = LandingPageFooter;
+_title = new WeakMap(), _backgroundColor = new WeakMap(), _buttonText = new WeakMap(), _buttonUrl = new WeakMap(), _textColor = new WeakMap(), _features = new WeakMap();
+//# sourceMappingURL=landingPageFooter.js.map

package/build/campaign/entities/campaign/landingPage/landingPageFooter/landingPageFooterFeature.d.ts

@@ -0,0 +1,22 @@
+import { AbstractEntity } from '../../../../../abstractEntity';
+export declare enum LandingPageFooterFeatureFields {
+    COLUMN_TITLE = "title",
+    COLUMN_DESCRIPTION = "description",
+    COLUMN_ICON = "icon",
+    COLUMN_SIZE = "size"
+}
+export declare type LandingPageFooterFeatureType = {
+    [LandingPageFooterFeatureFields.COLUMN_TITLE]?: string;
+    [LandingPageFooterFeatureFields.COLUMN_DESCRIPTION]?: string;
+    [LandingPageFooterFeatureFields.COLUMN_ICON]?: string;
+    [LandingPageFooterFeatureFields.COLUMN_SIZE]?: number;
+};
+export declare class LandingPageFooterFeature extends AbstractEntity<LandingPageFooterFeatureType> {
+    #private;
+    constructor(landingPageFooterFeatureInput: LandingPageFooterFeatureType);
+    get title(): string | undefined;
+    get description(): string | undefined;
+    get icon(): string | undefined;
+    get size(): number | undefined;
+    toJSON(): LandingPageFooterFeatureType;
+}

package/build/campaign/entities/campaign/landingPage/landingPageFooter/landingPageFooterFeature.js

@@ -0,0 +1,61 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _title, _description, _icon, _size;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandingPageFooterFeature = exports.LandingPageFooterFeatureFields = void 0;
+const abstractEntity_1 = require("../../../../../abstractEntity");
+var LandingPageFooterFeatureFields;
+(function (LandingPageFooterFeatureFields) {
+    LandingPageFooterFeatureFields["COLUMN_TITLE"] = "title";
+    LandingPageFooterFeatureFields["COLUMN_DESCRIPTION"] = "description";
+    LandingPageFooterFeatureFields["COLUMN_ICON"] = "icon";
+    LandingPageFooterFeatureFields["COLUMN_SIZE"] = "size";
+})(LandingPageFooterFeatureFields = exports.LandingPageFooterFeatureFields || (exports.LandingPageFooterFeatureFields = {}));
+class LandingPageFooterFeature extends abstractEntity_1.AbstractEntity {
+    constructor(landingPageFooterFeatureInput) {
+        super(landingPageFooterFeatureInput);
+        _title.set(this, void 0);
+        _description.set(this, void 0);
+        _icon.set(this, void 0);
+        _size.set(this, void 0);
+        __classPrivateFieldSet(this, _title, landingPageFooterFeatureInput[LandingPageFooterFeatureFields.COLUMN_TITLE]);
+        __classPrivateFieldSet(this, _description, landingPageFooterFeatureInput[LandingPageFooterFeatureFields.COLUMN_DESCRIPTION]);
+        __classPrivateFieldSet(this, _icon, landingPageFooterFeatureInput[LandingPageFooterFeatureFields.COLUMN_ICON]);
+        __classPrivateFieldSet(this, _size, landingPageFooterFeatureInput[LandingPageFooterFeatureFields.COLUMN_SIZE]);
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _title);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    get icon() {
+        return __classPrivateFieldGet(this, _icon);
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _size);
+    }
+    toJSON() {
+        return {
+            [LandingPageFooterFeatureFields.COLUMN_TITLE]: this.title,
+            [LandingPageFooterFeatureFields.COLUMN_DESCRIPTION]: this.description,
+            [LandingPageFooterFeatureFields.COLUMN_ICON]: this.icon,
+            [LandingPageFooterFeatureFields.COLUMN_SIZE]: this.size,
+        };
+    }
+}
+exports.LandingPageFooterFeature = LandingPageFooterFeature;
+_title = new WeakMap(), _description = new WeakMap(), _icon = new WeakMap(), _size = new WeakMap();
+//# sourceMappingURL=landingPageFooterFeature.js.map

package/build/campaign/entities/campaign/landingPage/landingPageHeader.d.ts

@@ -0,0 +1,28 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum LandingPageHeaderFields {
+    COLUMN_BACKGROUND_IMAGE_UUID = "backgroundImageUuid",
+    COLUMN_VENDOR_LOGO_UUID = "vendorLogoUuid",
+    COLUMN_TITLE = "title",
+    COLUMN_BACKGROUND_COLOR = "backgroundColor",
+    COLUMN_BASELINE = "baseline",
+    COLUMN_TEXT_COLOR = "textColor"
+}
+export declare type LandingPageHeaderType = {
+    [LandingPageHeaderFields.COLUMN_BACKGROUND_IMAGE_UUID]: string;
+    [LandingPageHeaderFields.COLUMN_VENDOR_LOGO_UUID]: string;
+    [LandingPageHeaderFields.COLUMN_TITLE]?: string;
+    [LandingPageHeaderFields.COLUMN_BACKGROUND_COLOR]?: string;
+    [LandingPageHeaderFields.COLUMN_BASELINE]?: string;
+    [LandingPageHeaderFields.COLUMN_TEXT_COLOR]?: string;
+};
+export declare class LandingPageHeader extends AbstractEntity<LandingPageHeaderType> {
+    #private;
+    constructor(landingPageHeaderInput: LandingPageHeaderType);
+    get backgroundImageUuid(): string;
+    get vendorLogoUuid(): string;
+    get title(): string | undefined;
+    get backgroundColor(): string | undefined;
+    get baseline(): string | undefined;
+    get textColor(): string | undefined;
+    toJSON(): LandingPageHeaderType;
+}

package/build/campaign/entities/campaign/landingPage/landingPageHeader.js

@@ -0,0 +1,76 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _backgroundImageUuid, _vendorLogoUuid, _title, _backgroundColor, _baseline, _textColor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandingPageHeader = exports.LandingPageHeaderFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var LandingPageHeaderFields;
+(function (LandingPageHeaderFields) {
+    LandingPageHeaderFields["COLUMN_BACKGROUND_IMAGE_UUID"] = "backgroundImageUuid";
+    LandingPageHeaderFields["COLUMN_VENDOR_LOGO_UUID"] = "vendorLogoUuid";
+    LandingPageHeaderFields["COLUMN_TITLE"] = "title";
+    LandingPageHeaderFields["COLUMN_BACKGROUND_COLOR"] = "backgroundColor";
+    LandingPageHeaderFields["COLUMN_BASELINE"] = "baseline";
+    LandingPageHeaderFields["COLUMN_TEXT_COLOR"] = "textColor";
+})(LandingPageHeaderFields = exports.LandingPageHeaderFields || (exports.LandingPageHeaderFields = {}));
+class LandingPageHeader extends abstractEntity_1.AbstractEntity {
+    constructor(landingPageHeaderInput) {
+        super(landingPageHeaderInput);
+        _backgroundImageUuid.set(this, void 0);
+        _vendorLogoUuid.set(this, void 0);
+        _title.set(this, void 0);
+        _backgroundColor.set(this, void 0);
+        _baseline.set(this, void 0);
+        _textColor.set(this, void 0);
+        __classPrivateFieldSet(this, _backgroundImageUuid, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_BACKGROUND_IMAGE_UUID]);
+        __classPrivateFieldSet(this, _vendorLogoUuid, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_VENDOR_LOGO_UUID]);
+        __classPrivateFieldSet(this, _title, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_TITLE]);
+        __classPrivateFieldSet(this, _backgroundColor, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_BACKGROUND_COLOR]);
+        __classPrivateFieldSet(this, _baseline, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_BASELINE]);
+        __classPrivateFieldSet(this, _textColor, landingPageHeaderInput[LandingPageHeaderFields.COLUMN_TEXT_COLOR]);
+    }
+    get backgroundImageUuid() {
+        return __classPrivateFieldGet(this, _backgroundImageUuid);
+    }
+    get vendorLogoUuid() {
+        return __classPrivateFieldGet(this, _vendorLogoUuid);
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _title);
+    }
+    get backgroundColor() {
+        return __classPrivateFieldGet(this, _backgroundColor);
+    }
+    get baseline() {
+        return __classPrivateFieldGet(this, _baseline);
+    }
+    get textColor() {
+        return __classPrivateFieldGet(this, _textColor);
+    }
+    toJSON() {
+        return {
+            [LandingPageHeaderFields.COLUMN_BACKGROUND_IMAGE_UUID]: this
+                .backgroundImageUuid,
+            [LandingPageHeaderFields.COLUMN_VENDOR_LOGO_UUID]: this.vendorLogoUuid,
+            [LandingPageHeaderFields.COLUMN_TITLE]: this.title,
+            [LandingPageHeaderFields.COLUMN_BACKGROUND_COLOR]: this.backgroundColor,
+            [LandingPageHeaderFields.COLUMN_BASELINE]: this.baseline,
+            [LandingPageHeaderFields.COLUMN_TEXT_COLOR]: this.textColor,
+        };
+    }
+}
+exports.LandingPageHeader = LandingPageHeader;
+_backgroundImageUuid = new WeakMap(), _vendorLogoUuid = new WeakMap(), _title = new WeakMap(), _backgroundColor = new WeakMap(), _baseline = new WeakMap(), _textColor = new WeakMap();
+//# sourceMappingURL=landingPageHeader.js.map

package/build/campaign/entities/campaign/rules/rules.d.ts

@@ -0,0 +1,28 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum RulesFields {
+    COLUMN_LOCATIONS = "locations",
+    COLUMN_ROLES = "roles",
+    COLUMN_MARKETPLACES = "marketplaces",
+    COLUMN_SUBSCRIPTIONS = "subscriptions",
+    COLUMN_RESELLERS = "resellers",
+    COLUMN_END_CUSTOMERS = "endCustomers"
+}
+export declare type RulesType = {
+    [RulesFields.COLUMN_LOCATIONS]: string[];
+    [RulesFields.COLUMN_ROLES]: string[];
+    [RulesFields.COLUMN_MARKETPLACES]: string[];
+    [RulesFields.COLUMN_SUBSCRIPTIONS]: string[];
+    [RulesFields.COLUMN_RESELLERS]: string[];
+    [RulesFields.COLUMN_END_CUSTOMERS]: string[];
+};
+export declare class Rules extends AbstractEntity<RulesType> {
+    #private;
+    constructor(rulesInput: RulesType);
+    get locations(): string[];
+    get roles(): string[];
+    get marketplaces(): string[];
+    get subscriptions(): string[];
+    get resellers(): string[];
+    get endCustomers(): string[];
+    toJSON(): RulesType;
+}

package/build/campaign/entities/campaign/rules/rules.js

@@ -0,0 +1,75 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _locations, _roles, _marketplaces, _subscriptions, _resellers, _endCustomers;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rules = exports.RulesFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var RulesFields;
+(function (RulesFields) {
+    RulesFields["COLUMN_LOCATIONS"] = "locations";
+    RulesFields["COLUMN_ROLES"] = "roles";
+    RulesFields["COLUMN_MARKETPLACES"] = "marketplaces";
+    RulesFields["COLUMN_SUBSCRIPTIONS"] = "subscriptions";
+    RulesFields["COLUMN_RESELLERS"] = "resellers";
+    RulesFields["COLUMN_END_CUSTOMERS"] = "endCustomers";
+})(RulesFields = exports.RulesFields || (exports.RulesFields = {}));
+class Rules extends abstractEntity_1.AbstractEntity {
+    constructor(rulesInput) {
+        super(rulesInput);
+        _locations.set(this, void 0);
+        _roles.set(this, void 0);
+        _marketplaces.set(this, void 0);
+        _subscriptions.set(this, void 0);
+        _resellers.set(this, void 0);
+        _endCustomers.set(this, void 0);
+        __classPrivateFieldSet(this, _locations, rulesInput[RulesFields.COLUMN_LOCATIONS]);
+        __classPrivateFieldSet(this, _roles, rulesInput[RulesFields.COLUMN_ROLES]);
+        __classPrivateFieldSet(this, _marketplaces, rulesInput[RulesFields.COLUMN_MARKETPLACES]);
+        __classPrivateFieldSet(this, _subscriptions, rulesInput[RulesFields.COLUMN_SUBSCRIPTIONS]);
+        __classPrivateFieldSet(this, _resellers, rulesInput[RulesFields.COLUMN_RESELLERS]);
+        __classPrivateFieldSet(this, _endCustomers, rulesInput[RulesFields.COLUMN_END_CUSTOMERS]);
+    }
+    get locations() {
+        return __classPrivateFieldGet(this, _locations);
+    }
+    get roles() {
+        return __classPrivateFieldGet(this, _roles);
+    }
+    get marketplaces() {
+        return __classPrivateFieldGet(this, _marketplaces);
+    }
+    get subscriptions() {
+        return __classPrivateFieldGet(this, _subscriptions);
+    }
+    get resellers() {
+        return __classPrivateFieldGet(this, _resellers);
+    }
+    get endCustomers() {
+        return __classPrivateFieldGet(this, _endCustomers);
+    }
+    toJSON() {
+        return {
+            [RulesFields.COLUMN_LOCATIONS]: this.locations,
+            [RulesFields.COLUMN_ROLES]: this.roles,
+            [RulesFields.COLUMN_MARKETPLACES]: this.marketplaces,
+            [RulesFields.COLUMN_SUBSCRIPTIONS]: this.subscriptions,
+            [RulesFields.COLUMN_RESELLERS]: this.resellers,
+            [RulesFields.COLUMN_END_CUSTOMERS]: this.endCustomers,
+        };
+    }
+}
+exports.Rules = Rules;
+_locations = new WeakMap(), _roles = new WeakMap(), _marketplaces = new WeakMap(), _subscriptions = new WeakMap(), _resellers = new WeakMap(), _endCustomers = new WeakMap();
+//# sourceMappingURL=rules.js.map

package/build/campaign/entities/campaignAssets/assets/assets.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum AssetsFields {
+    COLUMN_UUID = "uuid",
+    COLUMN_URL = "url"
+}
+export declare type AssetsType = {
+    [AssetsFields.COLUMN_UUID]: string;
+    [AssetsFields.COLUMN_URL]: string;
+};
+export declare class Assets extends AbstractEntity<AssetsType> {
+    #private;
+    constructor(assetsInput: AssetsType);
+    get uuid(): string;
+    get url(): string;
+    toJSON(): AssetsType;
+}

package/build/campaign/entities/campaignAssets/assets/assets.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _uuid, _url;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assets = exports.AssetsFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var AssetsFields;
+(function (AssetsFields) {
+    AssetsFields["COLUMN_UUID"] = "uuid";
+    AssetsFields["COLUMN_URL"] = "url";
+})(AssetsFields = exports.AssetsFields || (exports.AssetsFields = {}));
+class Assets extends abstractEntity_1.AbstractEntity {
+    constructor(assetsInput) {
+        super(assetsInput);
+        _uuid.set(this, void 0);
+        _url.set(this, void 0);
+        __classPrivateFieldSet(this, _uuid, assetsInput[AssetsFields.COLUMN_UUID]);
+        __classPrivateFieldSet(this, _url, assetsInput[AssetsFields.COLUMN_URL]);
+    }
+    get uuid() {
+        return __classPrivateFieldGet(this, _uuid);
+    }
+    get url() {
+        return __classPrivateFieldGet(this, _url);
+    }
+    toJSON() {
+        return {
+            [AssetsFields.COLUMN_UUID]: this.uuid,
+            [AssetsFields.COLUMN_URL]: this.url,
+        };
+    }
+}
+exports.Assets = Assets;
+_uuid = new WeakMap(), _url = new WeakMap();
+//# sourceMappingURL=assets.js.map

package/build/campaign/entities/campaignAssets/campaignAssets.d.ts

@@ -0,0 +1,14 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { AssetsType, Assets } from './assets/assets';
+export declare enum CampaignAssetsFields {
+    COLUMN_ASSETS = "assets"
+}
+export declare type CampaignAssetsType = {
+    [CampaignAssetsFields.COLUMN_ASSETS]: Array<AssetsType>;
+};
+export declare class CampaignAssets extends AbstractEntity<CampaignAssetsType> {
+    #private;
+    constructor(CampaignAssetsInput: CampaignAssetsType);
+    get assets(): Array<Assets>;
+    toJSON(): CampaignAssetsType;
+}

package/build/campaign/entities/campaignAssets/campaignAssets.js

@@ -0,0 +1,41 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _assets;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CampaignAssets = exports.CampaignAssetsFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const assets_1 = require("./assets/assets");
+var CampaignAssetsFields;
+(function (CampaignAssetsFields) {
+    CampaignAssetsFields["COLUMN_ASSETS"] = "assets";
+})(CampaignAssetsFields = exports.CampaignAssetsFields || (exports.CampaignAssetsFields = {}));
+class CampaignAssets extends abstractEntity_1.AbstractEntity {
+    constructor(CampaignAssetsInput) {
+        super(CampaignAssetsInput);
+        _assets.set(this, void 0);
+        __classPrivateFieldSet(this, _assets, CampaignAssetsInput[CampaignAssetsFields.COLUMN_ASSETS].map((asset) => new assets_1.Assets(asset)));
+    }
+    get assets() {
+        return __classPrivateFieldGet(this, _assets);
+    }
+    toJSON() {
+        return {
+            [CampaignAssetsFields.COLUMN_ASSETS]: this.assets.map((asset) => asset.toJSON()),
+        };
+    }
+}
+exports.CampaignAssets = CampaignAssets;
+_assets = new WeakMap();
+//# sourceMappingURL=campaignAssets.js.map

package/build/campaign/index.d.ts

@@ -0,0 +1,11 @@
+export * from './entities/campaign/banners/banners';
+export * from './entities/campaign/landingPage/landingPageFooter/landingPageFooter';
+export * from './entities/campaign/landingPage/landingPageFooter/landingPageFooterFeature';
+export * from './entities/campaign/landingPage/landingPage';
+export * from './entities/campaign/landingPage/landingPageBody';
+export * from './entities/campaign/landingPage/landingPageHeader';
+export * from './entities/campaign/rules/rules';
+export * from './entities/campaign/campaign';
+export * from './entities/campaignAssets/assets/assets';
+export * from './entities/campaignAssets/campaignAssets';
+export * from './campaignClient';

package/build/campaign/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/campaign/banners/banners"), exports);
+__exportStar(require("./entities/campaign/landingPage/landingPageFooter/landingPageFooter"), exports);
+__exportStar(require("./entities/campaign/landingPage/landingPageFooter/landingPageFooterFeature"), exports);
+__exportStar(require("./entities/campaign/landingPage/landingPage"), exports);
+__exportStar(require("./entities/campaign/landingPage/landingPageBody"), exports);
+__exportStar(require("./entities/campaign/landingPage/landingPageHeader"), exports);
+__exportStar(require("./entities/campaign/rules/rules"), exports);
+__exportStar(require("./entities/campaign/campaign"), exports);
+__exportStar(require("./entities/campaignAssets/assets/assets"), exports);
+__exportStar(require("./entities/campaignAssets/campaignAssets"), exports);
+__exportStar(require("./campaignClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/publicApiClient.d.ts

@@ -5,6 +5,7 @@ import { SubscriptionsClient } from './subscriptions/subscriptionsClient';
 import { CustomersClient } from './customers/customersClient';
 import { OrdersClient } from './orders';
 import { ContactClient } from './contact/contactClient';
+import { CampaignClient } from './campaign';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -45,5 +46,10 @@ export declare class PublicApiClient extends AbstractClient {
      * @returns {@link ContactClient}
      */
     getContactClient(): ContactClient;
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getCampaignClient(): CampaignClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -8,6 +8,7 @@ const subscriptionsClient_1 = require("./subscriptions/subscriptionsClient");
 const customersClient_1 = require("./customers/customersClient");
 const orders_1 = require("./orders");
 const contactClient_1 = require("./contact/contactClient");
+const campaign_1 = require("./campaign");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -78,6 +79,15 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setUrl(this.url)
             .setApiKey(this.apiKey);
     }
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getCampaignClient() {
+        return new campaign_1.CampaignClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.7.0",
+  "version": "3.8.0-rc.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -81,7 +81,7 @@
     "@types/validatorjs": "3.15.0",
     "axios": "0.21.1",
     "graphql": "^16.3.0",
-    "graphql-request": "^4.0.0",
+    "graphql-request": "4.2.0",
     "validatorjs": "3.22.1"
   }
 }