@polyvharmony/live-scenes-sdk 1.2.0-rc.1

package/src/main/ets/modules/player/PLVPlayerManager.js

@@ -0,0 +1,66 @@
+import { lazy, PLVMediaPlayer, PLVPlaybackListType, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVLoginType } from '../login/model/PLVLoginType';
+export class PLVPlayerManager extends PLVBaseModule {
+    constructor(c176) {
+        super(c176);
+        this._mainMediaPlayer = lazy(() => new PLVMediaPlayer());
+    }
+    get mainMediaPlayer() {
+        return this._mainMediaPlayer.value;
+    }
+    startMainMediaPlayerWithComponent(component) {
+        this.mainMediaPlayer.setXComponent(component);
+        this.setMainMediaPlayerResource();
+    }
+    setMainMediaPlayerResource() {
+        if (this.channelData.loginType === PLVLoginType.LIVE) {
+            this.mainMediaPlayer.setMediaResource({
+                channelId: requireNotNull(this.channelData.loginChannelId),
+                authentication: {
+                    userId: requireNotNull(this.channelData.userId),
+                    appId: requireNotNull(this.channelData.appId),
+                    appSecret: requireNotNull(this.channelData.appSecret),
+                },
+                viewerParam: {
+                    viewerId: requireNotNull(this.channelData.viewerId),
+                    viewerName: requireNotNull(this.channelData.viewerName),
+                    viewerAvatar: this.channelData.viewerAvatar,
+                    viewLogParam4: this.channelData.param4,
+                    viewLogParam5: this.channelData.param5,
+                },
+                scene: 'live'
+            });
+        }
+        else if (this.channelData.loginType === PLVLoginType.PLAYBACK) {
+            this.mainMediaPlayer.setMediaResource({
+                channelId: requireNotNull(this.channelData.loginChannelId),
+                authentication: {
+                    userId: requireNotNull(this.channelData.userId),
+                    appId: requireNotNull(this.channelData.appId),
+                    appSecret: requireNotNull(this.channelData.appSecret),
+                },
+                viewerParam: {
+                    viewerId: requireNotNull(this.channelData.viewerId),
+                    viewerName: requireNotNull(this.channelData.viewerName),
+                    viewerAvatar: this.channelData.viewerAvatar,
+                    viewLogParam4: this.channelData.param4,
+                    viewLogParam5: this.channelData.param5,
+                },
+                videoId: this.channelData.playbackVid,
+                playbackListType: PLVPlaybackListType.parseType(this.channelData.playbackListType),
+                scene: 'playback'
+            });
+        }
+    }
+    release() {
+        if (this._mainMediaPlayer.isInit) {
+            this.mainMediaPlayer.release();
+        }
+    }
+    destroy() {
+        if (this._mainMediaPlayer.isInit) {
+            this.mainMediaPlayer.destroy();
+        }
+    }
+}

package/src/main/ets/modules/player/PLVPlayerMediator.d.ets

@@ -0,0 +1,6 @@
+import { PLVPlayerManager } from "./PLVPlayerManager";
+export declare class PLVPlayerMediator {
+    private readonly playerManager;
+    constructor(e176: PLVPlayerManager);
+    get viewLogReportFrequency(): number;
+}

package/src/main/ets/modules/player/PLVPlayerMediator.js

@@ -0,0 +1,8 @@
+export class PLVPlayerMediator {
+    constructor(e176) {
+        this.playerManager = e176;
+    }
+    get viewLogReportFrequency() {
+        return this.playerManager.mainMediaPlayer.getBusinessListenerRegistry().liveChannelJson.value?.reportFreq ?? 10;
+    }
+}

package/src/main/ets/modules/player/playback/PLVPlaybackListType.d.ets

@@ -0,0 +1,5 @@
+export declare enum PLVPlaybackListType {
+    TEMP_STORE = "1",
+    PLAYBACK = "2",
+    VOD = "3"
+}

package/src/main/ets/modules/player/playback/PLVPlaybackListType.js

@@ -0,0 +1,6 @@
+export var PLVPlaybackListType;
+(function (b176) {
+    b176["TEMP_STORE"] = "1";
+    b176["PLAYBACK"] = "2";
+    b176["VOD"] = "3";
+})(PLVPlaybackListType || (PLVPlaybackListType = {}));

package/src/main/ets/modules/product/PLVProductManager.d.ets

@@ -0,0 +1,60 @@
+import { IPLVEventNotify } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVChannelData } from '../../common/PLVChannelData';
+import { PLVSocketMediator } from '../socket/PLVSocketMediator';
+import { PLVProductContentBean } from './model/PLVProductContentBean';
+import { PLVProductDataBean } from './model/PLVProductDataBean';
+/**
+ * 事件类型，可以使用{@link PLVProductManager#eventNotify}监听对应的事件
+ */
+export type EventType = 'product_data';
+/**
+ * 商品管理器
+ */
+export declare class PLVProductManager extends PLVBaseModule {
+    private productDataBean;
+    private productHotEffectBean?;
+    private socketMediator;
+    /**
+     * 事件通知
+     */
+    eventNotify: IPLVEventNotify<EventType>;
+    constructor(z177: PLVChannelData, a178: PLVSocketMediator);
+    /**
+     * 通知是否有商品推送
+     * @param pushContentBean 不为undefined即为有商品推送
+     */
+    notifyPush(y177?: PLVProductContentBean): void;
+    /**
+     * 通知商品库开关
+     * @param isOpen
+     */
+    notifyOpen(x177: boolean): void;
+    /**
+     * 通知商品推送的点击次数
+     * @param clickTimes
+     */
+    notifyClickTimes(w177: number): void;
+    /**
+     * 通知商品推送被移动
+     * @param showId
+     */
+    notifyMove(v177?: number): void;
+    /**
+     * 通知商品推送被点击
+     */
+    notifyClick(): Promise<void>;
+    /**
+     * 获取商品数据
+     * @returns
+     */
+    getData(): PLVProductDataBean;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+    private init;
+    private handleProductEvent;
+    private handleClickTimesEvent;
+    private getHotEffectTips;
+}

package/src/main/ets/modules/product/PLVProductManager.js

@@ -0,0 +1,155 @@
+import { PLVEventNotify, PLVJSONUtils, PLVLogger } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVSocketOnEvent } from '../socket/model/PLVSocketEventConstants';
+import { PLVLocalProductClickEvent } from './model/PLVLocalProductClickEvent';
+import { PLVProductClickTimesEvent } from './model/PLVProductClickTimesEvent';
+import { PLVProductControlEvent } from './model/PLVProductControlEvent';
+import { PLVProductDataBean } from './model/PLVProductDataBean';
+import { PLVProductEvent } from './model/PLVProductEvent';
+import { PLVProductMenuSwitchEvent } from './model/PLVProductMenuSwitchEvent';
+import { PLVProductMoveEvent } from './model/PLVProductMoveEvent';
+import { PLVProductRemoveEvent } from './model/PLVProductRemoveEvent';
+const TAG = '[PLVProductManager]';
+export class PLVProductManager extends PLVBaseModule {
+    constructor(z177, a178) {
+        super(z177);
+        this.productDataBean = new PLVProductDataBean();
+        this.eventNotify = new PLVEventNotify(this);
+        this.socketMediator = a178;
+        this.init();
+    }
+    notifyPush(y177) {
+        if (y177?.productId != this.productDataBean.pushContentBean?.productId) {
+            this.productDataBean.hotEffectClickTimes = 0;
+        }
+        this.productDataBean.hotEffectTips = this.getHotEffectTips(y177);
+        this.productDataBean.pushContentBean = y177;
+        this.eventNotify.emit('product_data', this.productDataBean.copy());
+    }
+    notifyOpen(x177) {
+        this.productDataBean.hotEffectClickTimes = 0;
+        this.productDataBean.pushContentBean = undefined;
+        this.productDataBean.isOpenProduct = x177;
+        this.eventNotify.emit('product_data', this.productDataBean.copy());
+    }
+    notifyClickTimes(w177) {
+        this.productDataBean.hotEffectClickTimes = w177;
+        this.eventNotify.emit('product_data', this.productDataBean.copy());
+    }
+    notifyMove(v177) {
+        if (this.productDataBean.pushContentBean) {
+            this.productDataBean.pushContentBean.showId = v177;
+        }
+        this.eventNotify.emit('product_data', this.productDataBean.copy());
+    }
+    async notifyClick() {
+        if (!this.productDataBean.pushContentBean) {
+            return;
+        }
+        PLVLogger.info(TAG, 'notifyClick');
+        const t177 = new PLVLocalProductClickEvent();
+        t177.data = {
+            type: this.productDataBean.pushContentBean.productType,
+            positionName: this.productDataBean.pushContentBean.name,
+            productId: this.productDataBean.pushContentBean.productId,
+            nickName: this.channelData.viewerName
+        };
+        t177.roomId = await this.channelData.loginRoomIdPromise.get();
+        const data = PLVJSONUtils.safeStringify(t177);
+        this.socketMediator.emit(PLVSocketOnEvent.PRODUCT, data, () => {
+            PLVLogger.info(TAG, 'notifyClick success');
+        });
+    }
+    getData() {
+        return this.productDataBean.copy();
+    }
+    destroy() {
+        this.eventNotify.clear();
+    }
+    async init() {
+        this.productDataBean.isOpenProduct = (await this.channelData.initializedPromise.get()).getMenuBuyBean() != undefined;
+        this.productDataBean.hotEffectEnable = (await this.channelData.initializedPromise.get()).liveDetail?.isProductHotEffectEnabled();
+        this.productHotEffectBean = (await this.channelData.initializedPromise.get()).liveDetail?.productHotEffectTips;
+        this.socketMediator.onData(PLVSocketOnEvent.MESSAGE, (data, event) => {
+            if (PLVProductEvent.EVENT === event) {
+                this.handleProductEvent(data);
+            }
+        }, this);
+        this.socketMediator.onData(PLVSocketOnEvent.PRODUCT, (data, event) => {
+            if (PLVProductClickTimesEvent.EVENT === event) {
+                if (this.productDataBean.hotEffectEnable) {
+                    this.handleClickTimesEvent(data);
+                }
+            }
+        }, this);
+    }
+    handleProductEvent(data) {
+        const l177 = PLVJSONUtils.json2Bean(PLVProductEvent, data);
+        if (!l177) {
+            return;
+        }
+        if (l177.isProductControlEvent()) {
+            const q177 = PLVJSONUtils.toFillData(PLVProductControlEvent, data);
+            if (!q177 || !q177.content) {
+                return;
+            }
+            if ((q177.isRedact() && this.productDataBean.pushContentBean?.productId === q177.content.productId) || q177.isPush()) {
+                this.notifyPush(q177.content);
+            }
+        }
+        else if (l177.isProductRemoveEvent()) {
+            const p177 = PLVJSONUtils.json2Bean(PLVProductRemoveEvent, data);
+            if (!p177 || !p177.content || !this.productDataBean.pushContentBean) {
+                return;
+            }
+            if (this.productDataBean.pushContentBean.productId === p177.content.productId) {
+                this.notifyPush(undefined);
+            }
+        }
+        else if (l177.isProductMoveEvent()) {
+            const n177 = PLVJSONUtils.json2Bean(PLVProductMoveEvent, data);
+            if (!n177 || !n177.content) {
+                return;
+            }
+            n177.content.some((value) => {
+                if (this.productDataBean.pushContentBean?.productId === value.productId) {
+                    this.notifyMove(value.showId);
+                    return true;
+                }
+                return false;
+            });
+        }
+        else if (l177.isProductMenuSwitchEvent()) {
+            const m177 = PLVJSONUtils.json2Bean(PLVProductMenuSwitchEvent, data);
+            if (!m177) {
+                return;
+            }
+            if (('Y' === m177.content?.enabled) === this.productDataBean.isOpenProduct) {
+                return;
+            }
+            this.notifyOpen(!this.productDataBean.isOpenProduct);
+        }
+    }
+    handleClickTimesEvent(data) {
+        const k177 = PLVJSONUtils.json2Bean(PLVProductClickTimesEvent, data);
+        if (k177 && k177.times) {
+            if (k177.productId === this.productDataBean.pushContentBean?.productId) {
+                this.notifyClickTimes(k177.times);
+            }
+        }
+    }
+    getHotEffectTips(j177) {
+        if (j177 && this.productHotEffectBean) {
+            if (j177.isNormalProduct()) {
+                return this.productHotEffectBean.normalProductTips;
+            }
+            else if (j177.isFinanceProduct()) {
+                return this.productHotEffectBean.financeProductTips;
+            }
+            else if (j177.isPositionProduct()) {
+                return this.productHotEffectBean.jobProductTips;
+            }
+        }
+        return undefined;
+    }
+}

package/src/main/ets/modules/product/components/PLVProductControlWeb.d.ets

@@ -0,0 +1,14 @@
+import { PLVLanguage } from '../../i18n/PLVLanguageManager';
+import { PLVSocketWebController } from '../../web/PLVSocketWebController';
+import { PLVInteractManager } from '../../interact/PLVInteractManager';
+@Component
+export declare struct PLVProductControlWeb {
+    controller: PLVSocketWebController;
+    interactManager: PLVInteractManager;
+    private url;
+    aboutToAppear(): void;
+    build(): void;
+    config(): void;
+    initUrl(data?: PLVLanguage): void;
+    aboutToDisappear(): void;
+}

package/src/main/ets/modules/product/components/PLVProductControlWeb.js

@@ -0,0 +1,86 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import { PLVSimpleWeb } from '@polyvharmony/live-scenes-foundation';
+import { PLVLanguage } from '../../i18n/PLVLanguageManager';
+import { EVENT_TYPE_LANGUAGE } from '../../web/PLVSocketWebController';
+import { lateInit } from '@polyvharmony/media-player-sdk';
+const TAG = '[PLVProductControlWeb]';
+const URL = 'https://websdk.videocc.net/interactions-launch-sdk-ui-webview/latest/product.html';
+export class PLVProductControlWeb extends ViewPU {
+    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
+        super(parent, __localStorage, elmtId, extraInfo);
+        if (typeof paramsLambda === "function") {
+            this.paramsGenerator_ = paramsLambda;
+        }
+        this.controller = lateInit();
+        this.interactManager = lateInit();
+        this.url = URL;
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.controller !== undefined) {
+            this.controller = params.controller;
+        }
+        if (params.interactManager !== undefined) {
+            this.interactManager = params.interactManager;
+        }
+        if (params.url !== undefined) {
+            this.url = params.url;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    }
+    aboutToBeDeleted() {
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    aboutToAppear() {
+        this.config();
+    }
+    initialRender() {
+        {
+            this.observeComponentCreation2((elmtId, isInitialRender) => {
+                if (isInitialRender) {
+                    let componentCall = new PLVSimpleWeb(this, {
+                        controller: this.controller,
+                        src: this.url
+                    }, undefined, elmtId, () => {
+                    }, { page: "sdk/src/main/ets/modules/product/components/PLVProductControlWeb.ets", line: 21, col: 5 });
+                    ViewPU.create(componentCall);
+                    let paramsLambda = () => {
+                        return {
+                            controller: this.controller,
+                            src: this.url
+                        };
+                    };
+                    componentCall.paramsGenerator_ = paramsLambda;
+                }
+                else {
+                    this.updateStateVarsOfChildByElmtId(elmtId, {});
+                }
+            }, { name: "PLVSimpleWeb" });
+        }
+    }
+    config() {
+        this.initUrl(this.controller?.channelData.language);
+        this.controller?.eventNotify.on(EVENT_TYPE_LANGUAGE, (data) => {
+            this.initUrl(data);
+            this.controller?.loadUrlCatch(this.url);
+        }, this);
+    }
+    initUrl(data) {
+        const lang = data == PLVLanguage.EN ? 'en' : 'zh_CN';
+        this.url = URL + `?lang=${lang}`;
+    }
+    aboutToDisappear() {
+        this.controller?.destroy();
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/product/components/PLVProductWeb.d.ets

@@ -0,0 +1,19 @@
+import { PLVLanguage } from '../../i18n/PLVLanguageManager';
+import { PLVSocketWebController } from '../../web/PLVSocketWebController';
+import { PLVInteractManager } from '../../interact/PLVInteractManager';
+export declare const EVENT_TYPE_CLICK_PRODUCT_BUTTON = "clickProductButton";
+export declare const EVENT_SHOW_JOB_DETAIL = "showJobDetail";
+@Component
+export declare struct PLVProductWeb {
+    @Link
+    controller: PLVSocketWebController | undefined;
+    @Link
+    interactManager: PLVInteractManager | undefined;
+    private url;
+    aboutToAppear(): void;
+    aboutToDisappear(): void;
+    build(): void;
+    config(): void;
+    initUrl(data?: PLVLanguage): void;
+    open(): void;
+}

package/src/main/ets/modules/product/components/PLVProductWeb.js

@@ -0,0 +1,123 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import { PLVJSONUtils, PLVLogger, PLVSimpleWeb } from '@polyvharmony/live-scenes-foundation';
+import { PLVLanguage } from '../../i18n/PLVLanguageManager';
+import { EVENT_TYPE_LANGUAGE } from '../../web/PLVSocketWebController';
+import { PLVProductContentBean } from '../model/PLVProductContentBean';
+import { PLVShowJobDetailEvent } from '../../socket/model/interact/PLVShowJobDetailEvent';
+const TAG = '[PLVProductWeb]';
+const URL = 'https://websdk.videocc.net/interactions-receive-sdk-ui-webview/latest/product.html';
+export const EVENT_TYPE_CLICK_PRODUCT_BUTTON = 'clickProductButton';
+export const EVENT_SHOW_JOB_DETAIL = 'showJobDetail';
+const LANG_EN = "en";
+const LANG_ZH = "zh_CN";
+export class PLVProductWeb extends ViewPU {
+    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
+        super(parent, __localStorage, elmtId, extraInfo);
+        if (typeof paramsLambda === "function") {
+            this.paramsGenerator_ = paramsLambda;
+        }
+        this.__controller = new SynchedPropertyObjectTwoWayPU(params.controller, this, "controller");
+        this.__interactManager = new SynchedPropertyObjectTwoWayPU(params.interactManager, this, "interactManager");
+        this.url = URL;
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.url !== undefined) {
+            this.url = params.url;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+        this.__controller.purgeDependencyOnElmtId(rmElmtId);
+        this.__interactManager.purgeDependencyOnElmtId(rmElmtId);
+    }
+    aboutToBeDeleted() {
+        this.__controller.aboutToBeDeleted();
+        this.__interactManager.aboutToBeDeleted();
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    get controller() {
+        return this.__controller.get();
+    }
+    set controller(newValue) {
+        this.__controller.set(newValue);
+    }
+    get interactManager() {
+        return this.__interactManager.get();
+    }
+    set interactManager(newValue) {
+        this.__interactManager.set(newValue);
+    }
+    aboutToAppear() {
+        this.config();
+    }
+    aboutToDisappear() {
+        this.controller?.destroy();
+    }
+    initialRender() {
+        {
+            this.observeComponentCreation2((elmtId, isInitialRender) => {
+                if (isInitialRender) {
+                    let componentCall = new PLVSimpleWeb(this, {
+                        controller: this.controller,
+                        src: this.url
+                    }, undefined, elmtId, () => {
+                    }, { page: "sdk/src/main/ets/modules/product/components/PLVProductWeb.ets", line: 36, col: 5 });
+                    ViewPU.create(componentCall);
+                    let paramsLambda = () => {
+                        return {
+                            controller: this.controller,
+                            src: this.url
+                        };
+                    };
+                    componentCall.paramsGenerator_ = paramsLambda;
+                }
+                else {
+                    this.updateStateVarsOfChildByElmtId(elmtId, {});
+                }
+            }, { name: "PLVSimpleWeb" });
+        }
+    }
+    config() {
+        this.initUrl(this.controller?.channelData.language);
+        this.controller?.eventNotify.on(EVENT_TYPE_LANGUAGE, (data) => {
+            this.initUrl(data);
+            this.controller?.loadUrlCatch(this.url);
+        }, this);
+        this.controller?.registerHandler(EVENT_TYPE_CLICK_PRODUCT_BUTTON, (data, callback) => {
+            const jsonObject = PLVJSONUtils.safeParse(data);
+            if (jsonObject) {
+                const q176 = PLVJSONUtils.bean2Bean(new PLVProductContentBean(), jsonObject['data']);
+                if (q176) {
+                    this.controller?.eventNotify.emit(EVENT_TYPE_CLICK_PRODUCT_BUTTON, q176);
+                }
+            }
+        });
+        this.controller?.registerHandler(EVENT_SHOW_JOB_DETAIL, (data, callback) => {
+            const p176 = PLVJSONUtils.json2Bean(PLVShowJobDetailEvent, data);
+            this.interactManager?.onShowJobDetail(p176);
+        });
+        this.controller?.addOnPageEnd(() => {
+            this.open();
+        });
+    }
+    initUrl(data) {
+        const lang = data == PLVLanguage.EN ? LANG_EN : LANG_ZH;
+        this.url = URL + `?lang=${lang}`;
+    }
+    open() {
+        const data = '{"event" : "OPEN_PRODUCT"}';
+        this.controller?.callWebHandle(data, (data) => {
+            PLVLogger.info(TAG, `OPEN_PRODUCT: ${data}`);
+        });
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/product/model/PLVLocalProductClickEvent.d.ets

@@ -0,0 +1,11 @@
+export declare class PLVLocalProductClickEvent {
+    EVENT: string;
+    roomId?: string;
+    data?: DataBean;
+}
+export interface DataBean {
+    productId?: number;
+    type?: string;
+    nickName?: string;
+    positionName?: string;
+}

package/src/main/ets/modules/product/model/PLVLocalProductClickEvent.js

@@ -0,0 +1,6 @@
+import { PLVSocketProductEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVLocalProductClickEvent {
+    constructor() {
+        this.EVENT = PLVSocketProductEvent.PRODUCT_CLICK;
+    }
+}

package/src/main/ets/modules/product/model/PLVProductClickTimesEvent.d.ets

@@ -0,0 +1,7 @@
+export declare class PLVProductClickTimesEvent {
+    static readonly EVENT = "PRODUCT_CLICK_TIMES";
+    type?: string;
+    positionName?: string;
+    times?: number;
+    productId?: number;
+}

package/src/main/ets/modules/product/model/PLVProductClickTimesEvent.js

@@ -0,0 +1,4 @@
+import { PLVSocketProductEvent } from '../../socket/model/PLVSocketEventConstants';
+export class PLVProductClickTimesEvent {
+}
+PLVProductClickTimesEvent.EVENT = PLVSocketProductEvent.PRODUCT_CLICK_TIMES;

package/src/main/ets/modules/product/model/PLVProductContentBean.d.ets

@@ -0,0 +1,43 @@
+@Observed
+export declare class PLVProductContentBean {
+    productId?: number;
+    userId?: string;
+    channelId?: string;
+    name?: string;
+    price?: string;
+    private cover?;
+    features?: string;
+    productDesc?: string;
+    link?: string;
+    status?: number;
+    createdTime?: number;
+    lastModified?: number;
+    rank?: number;
+    realPrice?: string;
+    type?: string;
+    linkType?: number;
+    pcLink?: string;
+    mobileLink?: string;
+    wxMiniprogramLink?: string;
+    wxMiniprogramOriginalId?: string;
+    showId?: number;
+    mobileAppLink?: string;
+    productType?: string;
+    productPushRule?: string;
+    yield?: string;
+    logId?: string;
+    params?: string;
+    parsedFeatures?: string[];
+    getCover(): string;
+    isNormalLink(): boolean;
+    getLinkByType(): string;
+    isRealPriceEqualsPrice(): boolean;
+    isFreeForPay(): boolean;
+    isSrcPriceZero(): boolean;
+    isNormalProduct(): boolean;
+    isFinanceProduct(): boolean;
+    isPositionProduct(): boolean;
+    isBigProduct(): boolean;
+    getParsedFeatures(maxLength?: number): string[];
+    getTreatment(): string;
+}