@be-link/ecommerce-backend-bff-service-node-sdk 0.0.112 → 0.0.115

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

@@ -0,0 +1,36 @@
+import type { TaskControllerTypes } from '@be-link/ecommerce-task-center-service-node-sdk';
+export declare namespace PandoraTaskService {
+    namespace Request {
+        type createTask = TaskControllerTypes.Request.createTask;
+        type updateTask = TaskControllerTypes.Request.updateTask;
+        type deleteTask = TaskControllerTypes.Request.deleteTask;
+        type getTask = TaskControllerTypes.Request.getTask;
+        type queryTaskList = TaskControllerTypes.Request.queryTaskList;
+        type startTask = TaskControllerTypes.Request.startTask;
+        type stopTask = TaskControllerTypes.Request.stopTask;
+        type queryTaskByProduct = TaskControllerTypes.Request.queryTaskByProduct;
+        type getRewardLog = TaskControllerTypes.Request.getRewardLog;
+    }
+    namespace Response {
+        type createTask = TaskControllerTypes.Response.createTask;
+        type updateTask = TaskControllerTypes.Response.updateTask;
+        type deleteTask = TaskControllerTypes.Response.deleteTask;
+        type getTask = TaskControllerTypes.Response.getTask;
+        type queryTaskList = TaskControllerTypes.Response.queryTaskList;
+        type startTask = TaskControllerTypes.Response.startTask;
+        type stopTask = TaskControllerTypes.Response.stopTask;
+        type queryTaskByProduct = TaskControllerTypes.Response.queryTaskByProduct;
+        type getRewardLog = TaskControllerTypes.Response.getRewardLog;
+    }
+    interface TaskController {
+        createTask(request: Request.createTask): any;
+        updateTask(request: Request.updateTask): any;
+        deleteTask(request: Request.deleteTask): any;
+        getTask(request: Request.getTask): any;
+        queryTaskList(request: Request.queryTaskList): any;
+        startTask(request: Request.startTask): any;
+        stopTask(request: Request.stopTask): any;
+        queryTaskByProduct(request: Request.queryTaskByProduct): any;
+        getRewardLog(request: Request.getRewardLog): any;
+    }
+}

package/cjs/bff/modules/pandora/task/types.js

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

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

@@ -0,0 +1,23 @@
+import { PandoraTaskWatchService as Service } from './types';
+import BaseService from '../../BaseService';
+import type { StandardResponse } from '../../../../types';
+/**
+ * PandoraTaskWatchService - Pandora 任务观看服务模块
+ * 提供观看任务相关的 API 方法
+ * 平台: pandora
+ */
+export declare class PandoraTaskWatchService extends BaseService implements Service.TaskWatchController {
+    protected prefixUrl: string;
+    /**
+     * 批量上报观看时长
+     * @param request - 请求参数
+     * @returns Promise，解析为标准响应格式
+     */
+    reportWatchTime(request: Service.Request.reportWatchTime): Promise<StandardResponse<Service.Response.reportWatchTime>>;
+    /**
+     * 批量查询直播间观看任务
+     * @param request - 请求参数
+     * @returns Promise，解析为标准响应格式
+     */
+    getWatchTasksByLiveRoom(request: Service.Request.getWatchTasksByLiveRoom): Promise<StandardResponse<Service.Response.getWatchTasksByLiveRoom>>;
+}

package/cjs/bff/modules/pandora/taskWatch/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.PandoraTaskWatchService = void 0;
+const BaseService_1 = __importDefault(require("../../BaseService"));
+/**
+ * PandoraTaskWatchService - Pandora 任务观看服务模块
+ * 提供观看任务相关的 API 方法
+ * 平台: pandora
+ */
+class PandoraTaskWatchService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/task-watch';
+    }
+    /**
+     * 批量上报观看时长
+     * @param request - 请求参数
+     * @returns Promise，解析为标准响应格式
+     */
+    reportWatchTime(request) {
+        return this.request(this.reportWatchTime, request);
+    }
+    /**
+     * 批量查询直播间观看任务
+     * @param request - 请求参数
+     * @returns Promise，解析为标准响应格式
+     */
+    getWatchTasksByLiveRoom(request) {
+        return this.request(this.getWatchTasksByLiveRoom, request);
+    }
+}
+exports.PandoraTaskWatchService = PandoraTaskWatchService;

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

@@ -0,0 +1,15 @@
+import type { TaskWatchControllerTypes } from '@be-link/ecommerce-task-center-service-node-sdk';
+export declare namespace PandoraTaskWatchService {
+    namespace Request {
+        type reportWatchTime = TaskWatchControllerTypes.Request.reportWatchTime;
+        type getWatchTasksByLiveRoom = TaskWatchControllerTypes.Request.getWatchTasksByLiveRoom;
+    }
+    namespace Response {
+        type reportWatchTime = TaskWatchControllerTypes.Response.reportWatchTime;
+        type getWatchTasksByLiveRoom = TaskWatchControllerTypes.Response.getWatchTasksByLiveRoom;
+    }
+    interface TaskWatchController {
+        reportWatchTime(request: Request.reportWatchTime): any;
+        getWatchTasksByLiveRoom(request: Request.getWatchTasksByLiveRoom): any;
+    }
+}

package/cjs/bff/modules/pandora/taskWatch/types.js

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

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

@@ -0,0 +1,20 @@
+import { PandoraUserService as Service } from './types';
+import BaseService from '../../BaseService';
+import type { StandardResponse } from '../../../../types';
+/**
+ * PandoraUserService - Pandora User 服务模块
+ * 提供 Pandora User 相关的 API 方法
+ * 平台: pandora
+ */
+export declare class PandoraUserService extends BaseService implements Service.UserController {
+    protected prefixUrl: string;
+    createAccount(request: Service.Request.createAccount): Promise<StandardResponse<Service.Response.createAccount>>;
+    updateAccount(request: Service.Request.updateAccount): Promise<StandardResponse<Service.Response.updateAccount>>;
+    deleteAccount(request: Service.Request.deleteAccount): Promise<StandardResponse<Service.Response.deleteAccount>>;
+    listAccounts(request: Service.Request.accountList): Promise<StandardResponse<Service.Response.accountList>>;
+    getUserInfo(request: Service.Request.getUserInfo): Promise<StandardResponse<Service.Response.getUserInfo>>;
+    getUserInfoByRole(): Promise<StandardResponse<Service.Response.getUserInfoByRole>>;
+    getUserRolePermissions(request: Service.Request.getUserRolePermissions): Promise<StandardResponse<Service.Response.getUserRolePermissions>>;
+    getStoreOptions(request: Service.Request.getStoreOptions): Promise<StandardResponse<Service.Response.getStoreOptions>>;
+    getUserNamesByIds(request: Service.Request.getUserNamesByIds): Promise<StandardResponse<Service.Response.getUserNamesByIds>>;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PandoraUserService = void 0;
+const BaseService_1 = __importDefault(require("../../BaseService"));
+/**
+ * PandoraUserService - Pandora User 服务模块
+ * 提供 Pandora User 相关的 API 方法
+ * 平台: pandora
+ */
+class PandoraUserService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/pandora/user';
+    }
+    createAccount(request) {
+        return this.request(this.createAccount, request);
+    }
+    updateAccount(request) {
+        return this.request(this.updateAccount, request);
+    }
+    deleteAccount(request) {
+        return this.request(this.deleteAccount, request);
+    }
+    listAccounts(request) {
+        return this.request(this.listAccounts, request);
+    }
+    getUserInfo(request) {
+        return this.request(this.getUserInfo, request);
+    }
+    getUserInfoByRole() {
+        return this.request(this.getUserInfoByRole, {});
+    }
+    getUserRolePermissions(request) {
+        return this.request(this.getUserRolePermissions, request);
+    }
+    getStoreOptions(request) {
+        return this.request(this.getStoreOptions, request);
+    }
+    getUserNamesByIds(request) {
+        return this.request(this.getUserNamesByIds, request);
+    }
+}
+exports.PandoraUserService = PandoraUserService;

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

@@ -0,0 +1,194 @@
+import { StandardResponse } from '../../../../types';
+import { PandoraCommonService } from '../common/types';
+export declare namespace PandoraUserService {
+    namespace Request {
+        /**
+         * 创建账号
+         */
+        interface createAccount {
+            phone: string;
+            name: string;
+            password: string;
+            roleId: string;
+            storeIds: string[];
+            warehouseIds: string[];
+            extraRules?: string[];
+            operatorRoleId: string;
+        }
+        /**
+         * 更新账号
+         */
+        interface updateAccount {
+            bindId: string;
+            name?: string;
+            storeIds?: string[];
+            warehouseIds?: string[];
+        }
+        /**
+         * 删除账号
+         */
+        interface deleteAccount {
+            bindId: string;
+        }
+        /**
+         * 账号列表查询
+         */
+        interface accountList {
+            name?: string;
+            phone?: string;
+            roleId?: string;
+            pageIndex: number;
+            pageSize: number;
+        }
+        /**
+         * 获取用户信息
+         */
+        interface getUserInfo {
+            id: string;
+        }
+        /**
+         * 获取用户角色权限（用于用户管理页面编辑权限回显）
+         */
+        interface getUserRolePermissions {
+            userId: string;
+            roleId: string;
+        }
+        /**
+         * 获取用户角色下的门店下拉框选项
+         */
+        interface getStoreOptions {
+            name?: string;
+        }
+        /**
+         * 批量获取用户名称
+         */
+        interface getUserNamesByIds {
+            ids: string[];
+        }
+    }
+    namespace Response {
+        /**
+         * 创建账号响应
+         */
+        interface createAccount {
+            userId: string;
+            bindId: string;
+        }
+        /**
+         * 更新账号响应
+         */
+        interface updateAccount {
+            success: boolean;
+        }
+        /**
+         * 删除账号响应
+         */
+        interface deleteAccount {
+            success: boolean;
+        }
+        /**
+         * 账号列表项
+         */
+        interface accountListItem {
+            userId: string;
+            bindId: string;
+            name: string;
+            phone: string;
+            role: {
+                id: string;
+                name: string;
+            };
+            stores: Array<{
+                id: string;
+                name: string;
+            }>;
+            warehouses: Array<{
+                id: string;
+                name: string;
+            }>;
+            createdAt: number;
+        }
+        /**
+         * 账号列表响应
+         */
+        interface accountList {
+            list: accountListItem[];
+            total: number;
+        }
+        /**
+         * 获取用户信息响应
+         */
+        interface getUserInfo {
+            id: string;
+            username: string;
+            phone: string;
+            status: string;
+            unionId: string;
+            openId: string;
+            createdAt: number;
+            updatedAt: number;
+        }
+        /**
+         * 根据角色获取用户信息响应（从请求上下文获取 userId 和 roleId）
+         */
+        interface getUserInfoByRole {
+            id: string;
+            username: string;
+            phone: string;
+            status: string;
+            hasAllStore: boolean;
+            hasAllWarehouse: boolean;
+            stores?: Array<{
+                id: string;
+                name: string;
+            }>;
+            roles?: Array<{
+                id: string;
+                name: string;
+            }>;
+            warehouses?: Array<{
+                id: string;
+                name: string;
+            }>;
+        }
+        /**
+         * 获取用户角色权限响应（用于用户管理页面编辑权限回显）
+         * operatorUserId 和 operatorRoleId 从请求上下文获取
+         */
+        interface getUserRolePermissions {
+            rules: PandoraCommonService.Response.RuleNode[];
+        }
+        /**
+         * 获取用户角色下的门店下拉框选项响应
+         */
+        interface getStoreOptions {
+            stores: Array<{
+                id: string;
+                name: string;
+            }>;
+        }
+        /**
+         * 批量获取用户名称响应
+         */
+        interface getUserNamesByIds {
+            users: Array<{
+                id: string;
+                name: string;
+            }>;
+        }
+    }
+    /**
+     * User Controller 接口定义
+     */
+    interface UserController {
+        createAccount(request: Request.createAccount): Promise<StandardResponse<Response.createAccount>>;
+        updateAccount(request: Request.updateAccount): Promise<StandardResponse<Response.updateAccount>>;
+        deleteAccount(request: Request.deleteAccount): Promise<StandardResponse<Response.deleteAccount>>;
+        listAccounts(request: Request.accountList): Promise<StandardResponse<Response.accountList>>;
+        getUserInfo(request: Request.getUserInfo): Promise<StandardResponse<Response.getUserInfo>>;
+        getUserInfoByRole(): Promise<StandardResponse<Response.getUserInfoByRole>>;
+        getUserRolePermissions(request: Request.getUserRolePermissions): Promise<StandardResponse<Response.getUserRolePermissions>>;
+        getStoreOptions(request: Request.getStoreOptions): Promise<StandardResponse<Response.getStoreOptions>>;
+        getUserNamesByIds(request: Request.getUserNamesByIds): Promise<StandardResponse<Response.getUserNamesByIds>>;
+    }
+}

package/cjs/bff/modules/pandora/user/types.js

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

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

@@ -0,0 +1,12 @@
+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>>;
+    createAddress(request: PandoraAddressManagementTypes.Request.createAddress): Promise<StandardResponse<PandoraAddressManagementTypes.Response.createAddress>>;
+    updateUserAddress(request: PandoraAddressManagementTypes.Request.updateUserAddress): Promise<StandardResponse<PandoraAddressManagementTypes.Response.updateUserAddress>>;
+    deleteAddress(request: PandoraAddressManagementTypes.Request.deleteAddress): Promise<StandardResponse<PandoraAddressManagementTypes.Response.deleteAddress>>;
+    setDefaultAddress(request: PandoraAddressManagementTypes.Request.setDefaultAddress): Promise<StandardResponse<PandoraAddressManagementTypes.Response.setDefaultAddress>>;
+}

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

@@ -0,0 +1,32 @@
+"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/usermanager/address';
+    }
+    getUserAddressList(request) {
+        return this.request(this.getUserAddressList, request);
+    }
+    getAddressDetail(request) {
+        return this.request(this.getAddressDetail, request);
+    }
+    createAddress(request) {
+        return this.request(this.createAddress, request);
+    }
+    updateUserAddress(request) {
+        return this.request(this.updateUserAddress, request);
+    }
+    deleteAddress(request) {
+        return this.request(this.deleteAddress, request);
+    }
+    setDefaultAddress(request) {
+        return this.request(this.setDefaultAddress, 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,12 @@
+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>>;
+    unbindUsersFromStore(request: PandoraUserManagementTypes.Request.unbindUsersFromStore): Promise<StandardResponse<PandoraUserManagementTypes.Response.unbindUsersFromStore>>;
+}

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

@@ -0,0 +1,32 @@
+"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);
+    }
+    unbindUsersFromStore(request) {
+        return this.request(this.unbindUsersFromStore, request);
+    }
+}
+exports.PandoraUserManagementService = PandoraUserManagementService;