@arrowsphere/api-client 3.6.0 → 3.8.0

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,12 @@
+import * as AssetsCampaignAssets from './entities/campaignAssets/assets/assets';
+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 { AssetsCampaignAssets };
+export * from './entities/campaignAssets/campaignAssets';
+export * from './campaignClient';

package/build/campaign/index.js

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+exports.AssetsCampaignAssets = void 0;
+const AssetsCampaignAssets = __importStar(require("./entities/campaignAssets/assets/assets"));
+exports.AssetsCampaignAssets = AssetsCampaignAssets;
+__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/campaignAssets"), exports);
+__exportStar(require("./campaignClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/customers/customersClient.d.ts

@@ -2,11 +2,13 @@ import { AbstractClient, Parameters } from '../abstractClient';
 import { GetResult } from '../getResult';
 import { DataCustomers } from './entities/dataCustomers';
 import { DataInvitation } from './entities/dataInvitation';
+import { DataListOrders } from '../orders';
 export declare class CustomersClient extends AbstractClient {
     /**
-     * The base path of the Customers API
+     * The base path of the API
      */
-    private ROOT_PATH;
+    protected basePath: string;
     getCustomers(parameters?: Parameters): Promise<GetResult<DataCustomers>>;
+    getCustomerOrders(customerRef: string, perPage?: number, page?: number, parameters?: Parameters): Promise<GetResult<DataListOrders>>;
     getCustomerInvitation(codeInvitation: string, parameters?: Parameters): Promise<GetResult<DataInvitation>>;
 }

package/build/customers/customersClient.js

@@ -5,20 +5,26 @@ const abstractClient_1 = require("../abstractClient");
 const getResult_1 = require("../getResult");
 const dataCustomers_1 = require("./entities/dataCustomers");
 const dataInvitation_1 = require("./entities/dataInvitation");
+const orders_1 = require("../orders");
 class CustomersClient extends abstractClient_1.AbstractClient {
     constructor() {
         super(...arguments);
         /**
-         * The base path of the Customers API
+         * The base path of the API
          */
-        this.ROOT_PATH = '/customers';
+        this.basePath = '/customers';
     }
     async getCustomers(parameters = {}) {
-        this.path = this.ROOT_PATH;
         return new getResult_1.GetResult(dataCustomers_1.DataCustomers, await this.get(parameters));
     }
+    async getCustomerOrders(customerRef, perPage = 25, page = 1, parameters = {}) {
+        this.setPerPage(perPage);
+        this.setPage(page);
+        this.path = `/${customerRef}/orders`;
+        return new getResult_1.GetResult(orders_1.DataListOrders, await this.get(parameters));
+    }
     async getCustomerInvitation(codeInvitation, parameters = {}) {
-        this.path = `${this.ROOT_PATH}/invitations/${codeInvitation}`;
+        this.path = `/invitations/${codeInvitation}`;
         return new getResult_1.GetResult(dataInvitation_1.DataInvitation, await this.get(parameters));
     }
 }

package/build/index.d.ts

@@ -4,6 +4,7 @@ export * from './publicGraphQLClient';
 export * from './abstractEntity';
 export * from './abstractClient';
 export * from './abstractGraphQLClient';
+export * from './campaign/';
 export * from './catalog/';
 export { ContactInformation };
 export * from './customers/';

package/build/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./abstractEntity"), exports);
 __exportStar(require("./abstractClient"), exports);
 __exportStar(require("./abstractGraphQLClient"), exports);
+__exportStar(require("./campaign/"), exports);
 __exportStar(require("./catalog/"), exports);
 __exportStar(require("./customers/"), exports);
 __exportStar(require("./general/"), exports);

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;