@be-link/ecommerce-backend-bff-service-node-sdk 0.0.95 → 0.0.97

package/cjs/bff/modules/pandora/product/service.d.ts

@@ -67,7 +67,7 @@ export declare class PandoraProductService extends BaseService implements Servic
      * @param request - 请求参数
      * @returns Promise，解析为标准响应格式
      */
-    queryProductSkuList(request: Service.Request.queryProductList): Promise<StandardResponse<Service.Response.queryProductSkuList>>;
+    queryProductSkuList(request: Service.Request.queryProductSkuList): Promise<StandardResponse<Service.Response.queryProductSkuList>>;
     /**
      * 商品二维码
      * @param request - 请求参数

package/cjs/bff/modules/pandora/product/types.d.ts

@@ -243,6 +243,32 @@ export declare namespace PandoraProductService {
             /** 上下架状态 */
             status?: string;
         }
+        interface queryProductSkuList {
+            /** 0 开始 */
+            pageIndex: number;
+            /** 页码数量 */
+            pageSize: number;
+            /** 商品Id列表 */
+            productIds?: string[];
+            /** SKU Id列表 */
+            skuIds?: string[];
+            /** 商品名称列表 */
+            productNames?: string[];
+            /** 69码列表 */
+            skuCodes?: string[];
+            /** 是否套餐 */
+            isCombo?: number;
+            /** 提货方式 */
+            pickTypes?: string[];
+            /** 配货方式 */
+            dispatchTypes?: string[];
+            /** 存储方式 */
+            storageMethods?: string[];
+            /** 商品分类 */
+            classifications?: string[];
+            /** 上下架状态 */
+            status?: string;
+        }
         interface productQrCode {
             /** 路径 */
             path: string;
@@ -442,7 +468,7 @@ export declare namespace PandoraProductService {
         /**
          * 获取商品+规格信息
          */
-        queryProductSkuList(request: PandoraProductService.Request.queryProductList): Promise<StandardResponse<PandoraProductService.Response.queryProductSkuList>>;
+        queryProductSkuList(request: PandoraProductService.Request.queryProductSkuList): Promise<StandardResponse<PandoraProductService.Response.queryProductSkuList>>;
         /**
          * 商品二维码
          */

package/cjs/bff/modules/pandora/userManager/service/address.service.d.ts

@@ -0,0 +1,10 @@
+import { PandoraAddressManagementTypes } from '../types/address.types';
+import BaseService from '../../../BaseService';
+import type { StandardResponse } from '../../../../../types';
+export declare class PandoraAddressManagementService extends BaseService implements PandoraAddressManagementTypes.Controller {
+    protected prefixUrl: string;
+    getUserAddressList(request: PandoraAddressManagementTypes.Request.getUserAddressList): Promise<StandardResponse<PandoraAddressManagementTypes.Response.getUserAddressList>>;
+    getAddressDetail(request: PandoraAddressManagementTypes.Request.getAddressDetail): Promise<StandardResponse<PandoraAddressManagementTypes.Response.getAddressDetail>>;
+    deleteUserAddress(request: PandoraAddressManagementTypes.Request.deleteUserAddress): Promise<StandardResponse<PandoraAddressManagementTypes.Response.deleteUserAddress>>;
+    batchDeleteAddresses(request: PandoraAddressManagementTypes.Request.batchDeleteAddresses): Promise<StandardResponse<PandoraAddressManagementTypes.Response.batchDeleteAddresses>>;
+}

package/cjs/bff/modules/pandora/userManager/service/address.service.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraAddressManagementService = void 0;
+const BaseService_1 = __importDefault(require("../../../BaseService"));
+class PandoraAddressManagementService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user-manager/address';
+    }
+    getUserAddressList(request) {
+        return this.request(this.getUserAddressList, request);
+    }
+    getAddressDetail(request) {
+        return this.request(this.getAddressDetail, request);
+    }
+    deleteUserAddress(request) {
+        return this.request(this.deleteUserAddress, request);
+    }
+    batchDeleteAddresses(request) {
+        return this.request(this.batchDeleteAddresses, request);
+    }
+}
+exports.PandoraAddressManagementService = PandoraAddressManagementService;

package/cjs/bff/modules/pandora/userManager/service/coupon.service.d.ts

@@ -0,0 +1,11 @@
+import { PandoraCouponManagementTypes } from '../types/coupon.types';
+import BaseService from '../../../BaseService';
+import type { StandardResponse } from '../../../../../types';
+export declare class PandoraCouponManagementService extends BaseService implements PandoraCouponManagementTypes.Controller {
+    protected prefixUrl: string;
+    batchGrantCoupons(request: PandoraCouponManagementTypes.Request.batchGrantCoupons): Promise<StandardResponse<PandoraCouponManagementTypes.Response.batchGrantCoupons>>;
+    grantCoupon(request: PandoraCouponManagementTypes.Request.grantCoupon): Promise<StandardResponse<PandoraCouponManagementTypes.Response.grantCoupon>>;
+    batchInvalidateCoupons(request: PandoraCouponManagementTypes.Request.batchInvalidateCoupons): Promise<StandardResponse<PandoraCouponManagementTypes.Response.batchInvalidateCoupons>>;
+    getUserCouponList(request: PandoraCouponManagementTypes.Request.getUserCouponList): Promise<StandardResponse<PandoraCouponManagementTypes.Response.getUserCouponList>>;
+    getCouponDetail(request: PandoraCouponManagementTypes.Request.getCouponDetail): Promise<StandardResponse<PandoraCouponManagementTypes.Response.getCouponDetail>>;
+}

package/cjs/bff/modules/pandora/userManager/service/coupon.service.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraCouponManagementService = void 0;
+const BaseService_1 = __importDefault(require("../../../BaseService"));
+class PandoraCouponManagementService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user-manager/coupon';
+    }
+    batchGrantCoupons(request) {
+        return this.request(this.batchGrantCoupons, request);
+    }
+    grantCoupon(request) {
+        return this.request(this.grantCoupon, request);
+    }
+    batchInvalidateCoupons(request) {
+        return this.request(this.batchInvalidateCoupons, request);
+    }
+    getUserCouponList(request) {
+        return this.request(this.getUserCouponList, request);
+    }
+    getCouponDetail(request) {
+        return this.request(this.getCouponDetail, request);
+    }
+}
+exports.PandoraCouponManagementService = PandoraCouponManagementService;

package/cjs/bff/modules/pandora/userManager/service/index.d.ts

@@ -0,0 +1,5 @@
+export * from './user.service';
+export * from './point.service';
+export * from './coupon.service';
+export * from './address.service';
+export * from './region.service';

package/cjs/bff/modules/pandora/userManager/service/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./user.service"), exports);
+__exportStar(require("./point.service"), exports);
+__exportStar(require("./coupon.service"), exports);
+__exportStar(require("./address.service"), exports);
+__exportStar(require("./region.service"), exports);

package/cjs/bff/modules/pandora/userManager/service/point.service.d.ts

@@ -0,0 +1,13 @@
+import { PandoraPointManagementTypes } from '../types/point.types';
+import BaseService from '../../../BaseService';
+import type { StandardResponse } from '../../../../../types';
+export declare class PandoraPointManagementService extends BaseService implements PandoraPointManagementTypes.Controller {
+    protected prefixUrl: string;
+    adjustPoint(request: PandoraPointManagementTypes.Request.adjustPoint): Promise<StandardResponse<PandoraPointManagementTypes.Response.adjustPoint>>;
+    batchAdjustPoints(request: PandoraPointManagementTypes.Request.batchAdjustPoints): Promise<StandardResponse<PandoraPointManagementTypes.Response.batchAdjustPoints>>;
+    getUserPointInfo(request: PandoraPointManagementTypes.Request.getUserPointInfo): Promise<StandardResponse<PandoraPointManagementTypes.Response.getUserPointInfo>>;
+    getPointFlowList(request: PandoraPointManagementTypes.Request.getPointFlowList): Promise<StandardResponse<PandoraPointManagementTypes.Response.getPointFlowList>>;
+    getPointDetailList(request: PandoraPointManagementTypes.Request.getPointDetailList): Promise<StandardResponse<PandoraPointManagementTypes.Response.getPointDetailList>>;
+    freezeUserPoint(request: PandoraPointManagementTypes.Request.freezeUserPoint): Promise<StandardResponse<PandoraPointManagementTypes.Response.freezeUserPoint>>;
+    unfreezeUserPoint(request: PandoraPointManagementTypes.Request.unfreezeUserPoint): Promise<StandardResponse<PandoraPointManagementTypes.Response.unfreezeUserPoint>>;
+}

package/cjs/bff/modules/pandora/userManager/service/point.service.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraPointManagementService = void 0;
+const BaseService_1 = __importDefault(require("../../../BaseService"));
+class PandoraPointManagementService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user-manager/point';
+    }
+    adjustPoint(request) {
+        return this.request(this.adjustPoint, request);
+    }
+    batchAdjustPoints(request) {
+        return this.request(this.batchAdjustPoints, request);
+    }
+    getUserPointInfo(request) {
+        return this.request(this.getUserPointInfo, request);
+    }
+    getPointFlowList(request) {
+        return this.request(this.getPointFlowList, request);
+    }
+    getPointDetailList(request) {
+        return this.request(this.getPointDetailList, request);
+    }
+    freezeUserPoint(request) {
+        return this.request(this.freezeUserPoint, request);
+    }
+    unfreezeUserPoint(request) {
+        return this.request(this.unfreezeUserPoint, request);
+    }
+}
+exports.PandoraPointManagementService = PandoraPointManagementService;

package/cjs/bff/modules/pandora/userManager/service/region.service.d.ts

@@ -0,0 +1,14 @@
+import { PandoraRegionManagementTypes } from '../types/region.types';
+import BaseService from '../../../BaseService';
+import type { StandardResponse } from '../../../../../types';
+export declare class PandoraRegionManagementService extends BaseService implements PandoraRegionManagementTypes.Controller {
+    protected prefixUrl: string;
+    batchImportRegions(request: PandoraRegionManagementTypes.Request.batchImportRegions): Promise<StandardResponse<PandoraRegionManagementTypes.Response.batchImportRegions>>;
+    getAllProvinces(request: PandoraRegionManagementTypes.Request.getAllProvinces): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getAllProvinces>>;
+    getCitiesByProvince(request: PandoraRegionManagementTypes.Request.getCitiesByProvince): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getCitiesByProvince>>;
+    getDistrictsByCity(request: PandoraRegionManagementTypes.Request.getDistrictsByCity): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getDistrictsByCity>>;
+    searchRegions(request: PandoraRegionManagementTypes.Request.searchRegions): Promise<StandardResponse<PandoraRegionManagementTypes.Response.searchRegions>>;
+    getRegionByCode(request: PandoraRegionManagementTypes.Request.getRegionByCode): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getRegionByCode>>;
+    getFullAddress(request: PandoraRegionManagementTypes.Request.getFullAddress): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getFullAddress>>;
+    getRegionTree(request: PandoraRegionManagementTypes.Request.getRegionTree): Promise<StandardResponse<PandoraRegionManagementTypes.Response.getRegionTree>>;
+}

package/cjs/bff/modules/pandora/userManager/service/region.service.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraRegionManagementService = void 0;
+const BaseService_1 = __importDefault(require("../../../BaseService"));
+class PandoraRegionManagementService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user-manager/region';
+    }
+    batchImportRegions(request) {
+        return this.request(this.batchImportRegions, request);
+    }
+    getAllProvinces(request) {
+        return this.request(this.getAllProvinces, request);
+    }
+    getCitiesByProvince(request) {
+        return this.request(this.getCitiesByProvince, request);
+    }
+    getDistrictsByCity(request) {
+        return this.request(this.getDistrictsByCity, request);
+    }
+    searchRegions(request) {
+        return this.request(this.searchRegions, request);
+    }
+    getRegionByCode(request) {
+        return this.request(this.getRegionByCode, request);
+    }
+    getFullAddress(request) {
+        return this.request(this.getFullAddress, request);
+    }
+    getRegionTree(request) {
+        return this.request(this.getRegionTree, request);
+    }
+}
+exports.PandoraRegionManagementService = PandoraRegionManagementService;

package/cjs/bff/modules/pandora/userManager/service/user.service.d.ts

@@ -0,0 +1,11 @@
+import { PandoraUserManagementTypes } from '../types/user.types';
+import BaseService from '../../../BaseService';
+import type { StandardResponse } from '../../../../../types';
+export declare class PandoraUserManagementService extends BaseService implements PandoraUserManagementTypes.Controller {
+    protected prefixUrl: string;
+    getUserList(request: PandoraUserManagementTypes.Request.getUserList): Promise<StandardResponse<PandoraUserManagementTypes.Response.getUserList>>;
+    getUserDetail(request: PandoraUserManagementTypes.Request.getUserDetail): Promise<StandardResponse<PandoraUserManagementTypes.Response.getUserDetail>>;
+    updateUserStatus(request: PandoraUserManagementTypes.Request.updateUserStatus): Promise<StandardResponse<PandoraUserManagementTypes.Response.updateUserStatus>>;
+    batchUpdateUserStatus(request: PandoraUserManagementTypes.Request.batchUpdateUserStatus): Promise<StandardResponse<PandoraUserManagementTypes.Response.batchUpdateUserStatus>>;
+    bindUsersToStore(request: PandoraUserManagementTypes.Request.bindUsersToStore): Promise<StandardResponse<PandoraUserManagementTypes.Response.bindUsersToStore>>;
+}

package/cjs/bff/modules/pandora/userManager/service/user.service.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraUserManagementService = void 0;
+const BaseService_1 = __importDefault(require("../../../BaseService"));
+class PandoraUserManagementService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user-manager/user';
+    }
+    getUserList(request) {
+        return this.request(this.getUserList, request);
+    }
+    getUserDetail(request) {
+        return this.request(this.getUserDetail, request);
+    }
+    updateUserStatus(request) {
+        return this.request(this.updateUserStatus, request);
+    }
+    batchUpdateUserStatus(request) {
+        return this.request(this.batchUpdateUserStatus, request);
+    }
+    bindUsersToStore(request) {
+        return this.request(this.bindUsersToStore, request);
+    }
+}
+exports.PandoraUserManagementService = PandoraUserManagementService;

package/cjs/bff/modules/pandora/userManager/types/address.types.d.ts

@@ -0,0 +1,68 @@
+import { StandardResponse } from '../../../../../types';
+export declare namespace PandoraAddressManagementTypes {
+    namespace Request {
+        interface getUserAddressList {
+            userId: string;
+        }
+        interface getAddressDetail {
+            id: string;
+            userId: string;
+        }
+        interface deleteUserAddress {
+            id: string;
+            userId: string;
+            operatorId: string;
+            reason?: string;
+        }
+        interface batchDeleteAddresses {
+            addresses: Array<{
+                id: string;
+                userId: string;
+            }>;
+            operatorId: string;
+            reason?: string;
+        }
+    }
+    namespace Response {
+        interface UserAddressDTO {
+            id?: string;
+            userId?: string;
+            name?: string;
+            mobile?: string;
+            provinceCode?: string;
+            provinceName?: string;
+            cityCode?: string;
+            cityName?: string;
+            districtCode?: string;
+            districtName?: string;
+            address?: string;
+            isDefault?: boolean;
+            createdAt?: number;
+            updatedAt?: number;
+        }
+        type getUserAddressList = UserAddressDTO[];
+        type getAddressDetail = UserAddressDTO;
+        interface deleteUserAddress {
+            success: boolean;
+        }
+        interface batchDeleteAddresses {
+            total: number;
+            success: number;
+            failed: number;
+            results: Array<{
+                addressId: string;
+                success: boolean;
+                data?: {
+                    success: boolean;
+                };
+                error?: string;
+            }>;
+        }
+    }
+    interface Controller {
+        getUserAddressList(request: Request.getUserAddressList): Promise<StandardResponse<Response.getUserAddressList>>;
+        getAddressDetail(request: Request.getAddressDetail): Promise<StandardResponse<Response.getAddressDetail>>;
+        deleteUserAddress(request: Request.deleteUserAddress): Promise<StandardResponse<Response.deleteUserAddress>>;
+        batchDeleteAddresses(request: Request.batchDeleteAddresses): Promise<StandardResponse<Response.batchDeleteAddresses>>;
+    }
+}

package/cjs/bff/modules/pandora/userManager/types/address.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/bff/modules/pandora/userManager/types/coupon.types.d.ts

@@ -0,0 +1,99 @@
+import { StandardResponse } from '../../../../../types';
+export declare namespace PandoraCouponManagementTypes {
+    namespace Request {
+        interface batchGrantCoupons {
+            list: Array<{
+                userId: string;
+                couponId: string;
+                couponName: string;
+                couponCode?: string;
+                couponType: string;
+                getChannel: string;
+                getBizId?: string;
+                startTime: number;
+                endTime: number;
+                couponInfo: object;
+                remark?: string;
+            }>;
+            operatorId: string;
+        }
+        interface grantCoupon {
+            userId: string;
+            couponId: string;
+            couponName: string;
+            couponCode: string;
+            couponType: string;
+            getChannel: string;
+            getBizId?: string;
+            startTime: number;
+            endTime: number;
+            couponInfo: object;
+            remark?: string;
+            operatorId: string;
+        }
+        interface batchInvalidateCoupons {
+            couponIds: Array<{
+                id: string;
+                userId: string;
+            }>;
+            operatorId: string;
+            reason?: string;
+        }
+        interface getUserCouponList {
+            userId: string;
+            status?: string;
+            couponType?: string;
+            limit?: number;
+            offset?: number;
+        }
+        interface getCouponDetail {
+            id: string;
+            userId: string;
+        }
+    }
+    namespace Response {
+        interface UserCouponDTO {
+            id?: string;
+            userId?: string;
+            couponId?: string;
+            couponName?: string;
+            couponCode?: string;
+            couponType?: string;
+            status?: string;
+            getChannel?: string;
+            startTime?: number;
+            endTime?: number;
+            couponInfo?: object;
+            createdAt?: number;
+            updatedAt?: number;
+        }
+        interface PageResponse<T> {
+            list: T[];
+            total: number;
+            limit: number;
+            offset: number;
+        }
+        type batchGrantCoupons = UserCouponDTO[];
+        type grantCoupon = UserCouponDTO;
+        interface batchInvalidateCoupons {
+            total: number;
+            success: number;
+            failed: number;
+            results: Array<{
+                couponId: string;
+                success: boolean;
+                data?: UserCouponDTO;
+                error?: string;
+            }>;
+        }
+        type getUserCouponList = PageResponse<UserCouponDTO>;
+        type getCouponDetail = UserCouponDTO;
+    }
+    interface Controller {
+        batchGrantCoupons(request: Request.batchGrantCoupons): Promise<StandardResponse<Response.batchGrantCoupons>>;
+        grantCoupon(request: Request.grantCoupon): Promise<StandardResponse<Response.grantCoupon>>;
+        batchInvalidateCoupons(request: Request.batchInvalidateCoupons): Promise<StandardResponse<Response.batchInvalidateCoupons>>;
+        getUserCouponList(request: Request.getUserCouponList): Promise<StandardResponse<Response.getUserCouponList>>;
+        getCouponDetail(request: Request.getCouponDetail): Promise<StandardResponse<Response.getCouponDetail>>;
+    }
+}

package/cjs/bff/modules/pandora/userManager/types/coupon.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/bff/modules/pandora/userManager/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './user.types';
+export * from './point.types';
+export * from './coupon.types';
+export * from './address.types';
+export * from './region.types';

package/cjs/bff/modules/pandora/userManager/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./user.types"), exports);
+__exportStar(require("./point.types"), exports);
+__exportStar(require("./coupon.types"), exports);
+__exportStar(require("./address.types"), exports);
+__exportStar(require("./region.types"), exports);

package/cjs/bff/modules/pandora/userManager/types/point.types.d.ts

@@ -0,0 +1,113 @@
+import { StandardResponse } from '../../../../../types';
+export declare namespace PandoraPointManagementTypes {
+    namespace Request {
+        interface adjustPoint {
+            userId: string;
+            point: number;
+            flowType: string;
+            remark: string;
+            expireTime?: number;
+            operatorId: string;
+            operatorName: string;
+        }
+        interface batchAdjustPoints {
+            adjustments: Array<{
+                userId: string;
+                point: number;
+                type: 'add' | 'deduct';
+                remark: string;
+            }>;
+            operatorId: string;
+            operatorName: string;
+        }
+        interface getUserPointInfo {
+            userId: string;
+        }
+        interface getPointFlowList {
+            userId: string;
+            flowType?: string;
+            limit?: number;
+            offset?: number;
+        }
+        interface getPointDetailList {
+            userId: string;
+            limit?: number;
+            offset?: number;
+        }
+        interface freezeUserPoint {
+            userId: string;
+            point: number;
+            remark: string;
+            operatorId: string;
+        }
+        interface unfreezeUserPoint {
+            userId: string;
+            point: number;
+            remark: string;
+            operatorId: string;
+        }
+    }
+    namespace Response {
+        interface UserPointDTO {
+            id?: string;
+            userId?: string;
+            totalPoint?: number;
+            availablePoint?: number;
+            frozenPoint?: number;
+            usedPoint?: number;
+            expiredPoint?: number;
+            createdAt?: number;
+            updatedAt?: number;
+        }
+        interface UserPointFlowDTO {
+            id?: string;
+            userId?: string;
+            flowType?: string;
+            point?: number;
+            beforePoint?: number;
+            afterPoint?: number;
+            remark?: string;
+            createdAt?: number;
+        }
+        interface UserPointDetailDTO {
+            id?: string;
+            userId?: string;
+            point?: number;
+            expireTime?: number;
+            status?: string;
+            createdAt?: number;
+        }
+        interface PageResponse<T> {
+            list: T[];
+            total: number;
+            limit: number;
+            offset: number;
+        }
+        type adjustPoint = UserPointDTO;
+        interface batchAdjustPoints {
+            total: number;
+            success: number;
+            failed: number;
+            results: Array<{
+                userId: string;
+                success: boolean;
+                data?: UserPointDTO;
+                error?: string;
+            }>;
+        }
+        type getUserPointInfo = UserPointDTO;
+        type getPointFlowList = PageResponse<UserPointFlowDTO>;
+        type getPointDetailList = PageResponse<UserPointDetailDTO>;
+        type freezeUserPoint = UserPointDTO;
+        type unfreezeUserPoint = UserPointDTO;
+    }
+    interface Controller {
+        adjustPoint(request: Request.adjustPoint): Promise<StandardResponse<Response.adjustPoint>>;
+        batchAdjustPoints(request: Request.batchAdjustPoints): Promise<StandardResponse<Response.batchAdjustPoints>>;
+        getUserPointInfo(request: Request.getUserPointInfo): Promise<StandardResponse<Response.getUserPointInfo>>;
+        getPointFlowList(request: Request.getPointFlowList): Promise<StandardResponse<Response.getPointFlowList>>;
+        getPointDetailList(request: Request.getPointDetailList): Promise<StandardResponse<Response.getPointDetailList>>;
+        freezeUserPoint(request: Request.freezeUserPoint): Promise<StandardResponse<Response.freezeUserPoint>>;
+        unfreezeUserPoint(request: Request.unfreezeUserPoint): Promise<StandardResponse<Response.unfreezeUserPoint>>;
+    }
+}

package/cjs/bff/modules/pandora/userManager/types/point.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });