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

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 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
+
+- Adding new EndPoint of Customer orders:
+  - Get customer orders
+
+## [3.6.0] - 2022-05-17
+
+### Changed
+
+- Adding 4 new EndPoints of Contact Information:
+  - Create Contact
+  - Get a Contact
+  - Get list of Contact
+  - Update a Contact
+
 ## [3.5.0] - 2022-05-02
 
 ### Changed

package/build/abstractClient.d.ts

@@ -112,6 +112,7 @@ export declare abstract class AbstractClient {
      */
     protected post(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<AxiosResponse['data']>;
     protected put(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<void>;
+    protected patch<T>(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<T>;
     /**
      * Generates the full url for request
      * @param parameters - Parameters to serialize

package/build/abstractClient.js

@@ -157,6 +157,12 @@ class AbstractClient {
         });
         return this.getResponse(response);
     }
+    async patch(payload = {}, parameters = {}, headers = {}, options = {}) {
+        const response = await this.client.patch(this.generateUrl(parameters, options), payload, {
+            headers: this.prepareHeaders(headers),
+        });
+        return this.getResponse(response);
+    }
     /**
      * Generates the full url for request
      * @param parameters - Parameters to serialize

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;
+}