@hecom/codearts 0.1.0

package/dist/commands/daily.command.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDailyReport = generateDailyReport;
+exports.dailyCommand = dailyCommand;
+const business_service_1 = require("../services/business.service");
+const config_loader_1 = require("../utils/config-loader");
+function isBug(workHour) {
+    return (workHour.issue_type === '缺陷' || workHour.issue_type === '3' || workHour.issue_type === 'Bug');
+}
+/**
+ * 生成单个角色的日报
+ */
+async function generateDailyReport(businessService, projectId, roleId, targetDate) {
+    const roleMembers = await businessService.getMembersByRoleId(projectId, roleId);
+    if (roleMembers.length === 0) {
+        console.log(`角色ID ${roleId} 未找到用户，跳过工时查询`);
+        return;
+    }
+    const roleName = roleMembers[0].role_name;
+    const roleUserIds = roleMembers.map((member) => member.user_id);
+    const dailyStats = await businessService.getDailyWorkHourStats(projectId, roleUserIds, targetDate);
+    const activeIssueIds = new Set();
+    dailyStats.userStats.forEach((userStat) => {
+        userStat.workHours.forEach((workHour) => {
+            activeIssueIds.add(workHour.issue_id);
+        });
+    });
+    const bugWorkHoursMap = new Map();
+    dailyStats.userStats.forEach((userStat) => {
+        userStat.workHours.forEach((workHour) => {
+            if (isBug(workHour)) {
+                const key = workHour.subject;
+                const hours = parseFloat(workHour.work_hours_num) || 0;
+                if (bugWorkHoursMap.has(key)) {
+                    const existing = bugWorkHoursMap.get(key);
+                    existing.users.add(workHour.nick_name);
+                    existing.totalHours += hours;
+                }
+                else {
+                    bugWorkHoursMap.set(key, {
+                        title: workHour.subject,
+                        users: new Set([workHour.nick_name]),
+                        totalHours: hours,
+                    });
+                }
+            }
+        });
+    });
+    const bugWorkHours = Array.from(bugWorkHoursMap.values()).map((bug) => ({
+        title: bug.title,
+        nick_name: Array.from(bug.users).join('、'),
+        work_hours: bug.totalHours.toString(),
+    }));
+    console.log(`\n${dailyStats.date} 日报 [${roleName}]:`);
+    console.log('='.repeat(50));
+    dailyStats.userStats.forEach((userStat) => {
+        console.log(`\n\x1b[31m${userStat.userName} 工时: ${userStat.totalHours}小时\x1b[0m`);
+        userStat.workHours.forEach((workHour) => {
+            const summaryPart = workHour.summary && workHour.summary.trim() !== ''
+                ? ` \x1b[36m${workHour.summary}\x1b[0m`
+                : '';
+            const workHoursTypePart = workHour.work_hours_type_name
+                ? ` (${workHour.work_hours_type_name})`
+                : '';
+            console.log(` - ${workHour.subject}${summaryPart} (${workHour.issue_type})${workHoursTypePart} ${workHour.work_hours_num}小时`);
+        });
+    });
+    console.log('\n\n');
+    console.log(`总结报告 [${roleName}]:`);
+    console.log('='.repeat(50));
+    let index = 1;
+    if (bugWorkHours.length > 0) {
+        console.log(`\n${index}.Bug跟进: ${bugWorkHours.length}项`);
+        if (bugWorkHours.length < 6) {
+            bugWorkHours.forEach((bug) => {
+                console.log(` - ${bug.title} ${bug.nick_name}`);
+            });
+        }
+        index++;
+    }
+    const activeIterations = await businessService.getActiveIterationsOnDate(projectId, targetDate);
+    if (activeIterations.length === 0) {
+        console.log('没有找到正在进行中的迭代');
+        return;
+    }
+    const activeIterationIds = activeIterations.map((iteration) => iteration.id);
+    const issues = await businessService.getWorkloadByIterationsAndUsers(projectId, activeIterationIds, roleUserIds);
+    const activeIssues = issues.filter((issue) => activeIssueIds.has(issue.id));
+    if (activeIssues.length !== 0) {
+        const activeIssuesByIteration = new Map();
+        activeIssues.forEach((issue) => {
+            const iterationId = issue.iteration.id;
+            if (!activeIssuesByIteration.has(iterationId)) {
+                activeIssuesByIteration.set(iterationId, []);
+            }
+            activeIssuesByIteration.get(iterationId).push(issue);
+        });
+        const issuesByIteration = new Map();
+        issues.forEach((issue) => {
+            const iterationId = issue.iteration.id;
+            if (!issuesByIteration.has(iterationId)) {
+                issuesByIteration.set(iterationId, []);
+            }
+            issuesByIteration.get(iterationId).push(issue);
+        });
+        activeIterations.forEach((iteration) => {
+            const iterationActiveIssues = activeIssuesByIteration.get(iteration.id) || [];
+            if (iterationActiveIssues.length === 0) {
+                return;
+            }
+            const iterationIssues = issuesByIteration.get(iteration.id) || [];
+            if (iterationIssues.length > 0) {
+                const iterationStats = businessService.calculateWorkProgress(iterationIssues);
+                console.log(`${index}.${iteration.name} ${iterationStats.overallCompletionRate}%`);
+                index++;
+            }
+            iterationActiveIssues.forEach((issue) => {
+                const doneRate = issue.expected_work_hours
+                    ? issue.actual_work_hours / issue.expected_work_hours
+                    : 0;
+                const displayDoneRate = issue.done_ratio
+                    ? issue.done_ratio
+                    : Math.round(Math.min(doneRate * 100, 100));
+                console.log(` - ${issue.name} ${displayDoneRate}% ${issue.assigned_user.nick_name}`);
+            });
+        });
+    }
+    const displayedIssueIds = new Set();
+    activeIssues.forEach((issue) => {
+        displayedIssueIds.add(issue.id);
+    });
+    const subjectMap = {
+        '【移动端】会议、调研、环境处理等零散工作': '',
+        '【移动端】【鸿蒙】调研、问题修复、打包等零散工作': '【鸿蒙】',
+        // 可在此添加更多映射
+    };
+    const otherWorkHours = [];
+    dailyStats.userStats.forEach((userStat) => {
+        userStat.workHours.forEach((workHour) => {
+            if (workHour.summary &&
+                workHour.summary.trim() !== '' &&
+                !isBug(workHour) &&
+                !displayedIssueIds.has(workHour.issue_id)) {
+                const subject = subjectMap[workHour.subject] ?? workHour.subject;
+                otherWorkHours.push({
+                    subject,
+                    summary: workHour.summary,
+                    nick_name: workHour.nick_name,
+                });
+            }
+        });
+    });
+    if (otherWorkHours.length > 0) {
+        console.log(`${index}.其他: ${otherWorkHours.length}项`);
+        otherWorkHours.forEach((work) => {
+            const subjectPart = work.subject ? `${work.subject} ` : '';
+            console.log(` - ${subjectPart}${work.summary} ${work.nick_name}`);
+        });
+        index++;
+    }
+    console.log(`${index}.工时: ${dailyStats.totalHours}`);
+}
+/**
+ * daily 命令入口
+ */
+async function dailyCommand(date, cliOptions = {}) {
+    try {
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        console.log(`开始统计 ${targetDate} 的日报...`);
+        const { projectId, roleIds, config } = (0, config_loader_1.loadConfig)(cliOptions);
+        const businessService = new business_service_1.BusinessService(config);
+        for (let i = 0; i < roleIds.length; i++) {
+            const roleId = roleIds[i];
+            if (i > 0) {
+                console.log('\n\n' + '='.repeat(80) + '\n');
+            }
+            await generateDailyReport(businessService, projectId, roleId, targetDate);
+        }
+    }
+    catch (error) {
+        console.error('执行过程中发生错误:', error);
+        process.exit(1);
+    }
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { dailyCommand } from './daily.command';
+export { workHourCommand } from './work-hour.command';
+export { configCommand } from './config.command';

package/dist/commands/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = exports.workHourCommand = exports.dailyCommand = void 0;
+var daily_command_1 = require("./daily.command");
+Object.defineProperty(exports, "dailyCommand", { enumerable: true, get: function () { return daily_command_1.dailyCommand; } });
+var work_hour_command_1 = require("./work-hour.command");
+Object.defineProperty(exports, "workHourCommand", { enumerable: true, get: function () { return work_hour_command_1.workHourCommand; } });
+var config_command_1 = require("./config.command");
+Object.defineProperty(exports, "configCommand", { enumerable: true, get: function () { return config_command_1.configCommand; } });

package/dist/commands/work-hour.command.d.ts

@@ -0,0 +1,5 @@
+import { CliOptions } from '../utils/config-loader';
+/**
+ * work-hour 命令入口
+ */
+export declare function workHourCommand(year?: string, cliOptions?: CliOptions): Promise<void>;

package/dist/commands/work-hour.command.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workHourCommand = workHourCommand;
+const holidays_1 = require("../config/holidays");
+const business_service_1 = require("../services/business.service");
+const config_loader_1 = require("../utils/config-loader");
+/**
+ * work-hour 命令入口
+ */
+async function workHourCommand(year, cliOptions = {}) {
+    try {
+        const targetYear = year || new Date().getFullYear().toString();
+        console.log(`开始获取 ${targetYear} 年工时统计...`);
+        const { projectId, roleIds, config } = (0, config_loader_1.loadConfig)(cliOptions);
+        const businessService = new business_service_1.BusinessService(config);
+        // 收集所有角色的成员和工时数据
+        const allMembers = [];
+        const allUserStats = [];
+        const allTypes = new Set();
+        for (const roleId of roleIds) {
+            const roleMembers = await businessService.getMembersByRoleId(projectId, roleId);
+            if (roleMembers.length === 0) {
+                console.log(`角色ID ${roleId} 未找到用户，跳过`);
+                continue;
+            }
+            const roleName = roleMembers[0].role_name;
+            allMembers.push(...roleMembers);
+            const roleUserIds = roleMembers.map((member) => member.user_id);
+            const stats = await businessService.getAllWorkHourStats(projectId, roleUserIds, `${targetYear}-01-01`, `${targetYear}-12-31`);
+            // 为每个用户添加角色信息
+            stats.userStats.forEach((userStat) => {
+                allUserStats.push({
+                    ...userStat,
+                    roleName,
+                    roleId,
+                });
+                // 收集所有领域类型
+                userStat.domainStats.forEach((domainStat) => {
+                    allTypes.add(domainStat.type);
+                });
+            });
+        }
+        if (allMembers.length === 0) {
+            console.log('未找到任何角色的用户');
+            return;
+        }
+        // 按角色ID排序用户
+        allUserStats.sort((a, b) => {
+            if (a.roleId !== b.roleId) {
+                return a.roleId - b.roleId;
+            }
+            return a.userName.localeCompare(b.userName);
+        });
+        const expectedWorkdays = (0, holidays_1.calculateExpectedWorkdays)(targetYear);
+        const expectedHoursPerPerson = expectedWorkdays * 8;
+        const totalExpectedHours = expectedHoursPerPerson * allMembers.length;
+        // 计算总工时
+        const totalHours = allUserStats.reduce((sum, userStat) => sum + userStat.totalHours, 0);
+        const totalEntries = allUserStats.reduce((sum, userStat) => sum + userStat.domainStats.reduce((s, d) => s + d.workHours.length, 0), 0);
+        console.log(`\n${targetYear}年工时统计报告`);
+        console.log('='.repeat(80));
+        console.log(`统计期间: ${targetYear}-01-01 至 ${targetYear}-12-31`);
+        console.log(`统计角色: ${roleIds.length} 个角色`);
+        console.log(`统计人数: ${allMembers.length} 人`);
+        console.log(`应计工作日: ${expectedWorkdays} 天`);
+        console.log(`应计工时: ${totalExpectedHours} 小时 (${expectedHoursPerPerson} 小时/人)`);
+        console.log(`实际工时: ${totalHours} 小时`);
+        console.log(`工时完成率: ${((totalHours / totalExpectedHours) * 100).toFixed(2)}%`);
+        console.log(`工时条目: ${totalEntries} 条`);
+        console.log('='.repeat(80));
+        // 构建表格数据：人作为行，type作为列
+        const tableData = {};
+        const typeTotals = {};
+        // 初始化总计
+        allTypes.forEach((type) => {
+            typeTotals[type] = 0;
+        });
+        // 按角色分组并填充数据
+        let currentRoleId = null;
+        let currentRoleName = '';
+        const roleSubtotals = {};
+        allUserStats.forEach((userStat, index) => {
+            // 检测角色变化，插入小计行
+            if (currentRoleId !== null && currentRoleId !== userStat.roleId) {
+                const subtotalRow = {};
+                subtotalRow['角色'] = `${currentRoleName} 小计`;
+                let subtotal = 0;
+                allTypes.forEach((type) => {
+                    subtotalRow[type] = roleSubtotals[type] || 0;
+                    subtotal += roleSubtotals[type] || 0;
+                });
+                subtotalRow['合计'] = subtotal;
+                tableData[`─ ${currentRoleName} 小计`] = subtotalRow;
+                // 重置小计
+                Object.keys(roleSubtotals).forEach((key) => {
+                    roleSubtotals[key] = 0;
+                });
+            }
+            // 更新当前角色
+            currentRoleId = userStat.roleId;
+            currentRoleName = userStat.roleName;
+            // 填充用户数据
+            const row = {};
+            row['角色'] = userStat.roleName;
+            // 初始化所有类型为0
+            allTypes.forEach((type) => {
+                row[type] = 0;
+            });
+            // 填充实际工时
+            let userTotal = 0;
+            userStat.domainStats.forEach((domainStat) => {
+                row[domainStat.type] = domainStat.totalHours;
+                userTotal += domainStat.totalHours;
+                typeTotals[domainStat.type] += domainStat.totalHours;
+                // 累加到角色小计
+                if (!roleSubtotals[domainStat.type]) {
+                    roleSubtotals[domainStat.type] = 0;
+                }
+                roleSubtotals[domainStat.type] += domainStat.totalHours;
+            });
+            row['合计'] = userTotal;
+            tableData[userStat.userName] = row;
+            // 如果是最后一个用户，添加最后一个角色的小计
+            if (index === allUserStats.length - 1) {
+                const subtotalRow = {};
+                subtotalRow['角色'] = `${currentRoleName} 小计`;
+                let subtotal = 0;
+                allTypes.forEach((type) => {
+                    subtotalRow[type] = roleSubtotals[type] || 0;
+                    subtotal += roleSubtotals[type] || 0;
+                });
+                subtotalRow['合计'] = subtotal;
+                tableData[`─ ${currentRoleName} 小计`] = subtotalRow;
+            }
+        });
+        // 添加总计行
+        const totalRow = {};
+        totalRow['角色'] = '━ 总计';
+        let grandTotal = 0;
+        allTypes.forEach((type) => {
+            totalRow[type] = typeTotals[type];
+            grandTotal += typeTotals[type];
+        });
+        totalRow['合计'] = grandTotal;
+        tableData['━━ 总计'] = totalRow;
+        console.log('\n工时统计表:');
+        console.table(tableData);
+    }
+    catch (error) {
+        console.error('执行过程中发生错误:', error);
+        process.exit(1);
+    }
+}

package/dist/config/holidays.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 中国法定节假日配置
+ *
+ * 配置说明：
+ * - festivals: 按节日类型组织的假期配置
+ * - adjustedWorkdays: 按月份组织的调休工作日
+ * - bigSmallWeekWorkdays: 按月份组织的大小周制度工作日
+ *
+ * 数据来源：国务院办公厅每年发布的节假日安排通知
+ */
+/** 法定节假日枚举 */
+declare enum FestivalType {
+    NewYear = "\u5143\u65E6",
+    SpringFestival = "\u6625\u8282",
+    TombSweepingDay = "\u6E05\u660E\u8282",
+    LaborDay = "\u52B3\u52A8\u8282",
+    DragonBoatFestival = "\u7AEF\u5348\u8282",
+    MidAutumnFestival = "\u4E2D\u79CB\u8282",
+    NationalDay = "\u56FD\u5E86\u8282"
+}
+/** 节日配置 */
+interface FestivalConfig {
+    type: FestivalType;
+    dates: string[];
+    adjustedDays?: string[];
+}
+/** 年度假期配置 */
+interface HolidayConfig {
+    festivals: Record<FestivalType, FestivalConfig>;
+    bigWeekWorkdays: [
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[],
+        string[]
+    ];
+}
+export declare const HOLIDAYS: Record<string, HolidayConfig>;
+/**
+ * 格式化日期为 YYYY-MM-DD
+ */
+export declare function formatDate(date: Date): string;
+/**
+ * 判断是否为工作日
+ */
+export declare function isWorkday(date: Date, year: string): boolean;
+/**
+ * 计算工作日
+ * @param year 年份
+ * @returns 应计工作日天数
+ */
+export declare function calculateExpectedWorkdays(year: string): number;
+export {};

package/dist/config/holidays.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * 中国法定节假日配置
+ *
+ * 配置说明：
+ * - festivals: 按节日类型组织的假期配置
+ * - adjustedWorkdays: 按月份组织的调休工作日
+ * - bigSmallWeekWorkdays: 按月份组织的大小周制度工作日
+ *
+ * 数据来源：国务院办公厅每年发布的节假日安排通知
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOLIDAYS = void 0;
+exports.formatDate = formatDate;
+exports.isWorkday = isWorkday;
+exports.calculateExpectedWorkdays = calculateExpectedWorkdays;
+/** 法定节假日枚举 */
+var FestivalType;
+(function (FestivalType) {
+    FestivalType["NewYear"] = "\u5143\u65E6";
+    FestivalType["SpringFestival"] = "\u6625\u8282";
+    FestivalType["TombSweepingDay"] = "\u6E05\u660E\u8282";
+    FestivalType["LaborDay"] = "\u52B3\u52A8\u8282";
+    FestivalType["DragonBoatFestival"] = "\u7AEF\u5348\u8282";
+    FestivalType["MidAutumnFestival"] = "\u4E2D\u79CB\u8282";
+    FestivalType["NationalDay"] = "\u56FD\u5E86\u8282";
+})(FestivalType || (FestivalType = {}));
+exports.HOLIDAYS = {
+    '2026': {
+        festivals: {
+            [FestivalType.NewYear]: {
+                type: FestivalType.NewYear,
+                dates: ['2026-01-01', '2026-01-02', '2026-01-03'],
+                adjustedDays: ['2026-01-04'], // 1月4日（周日）上班
+            },
+            [FestivalType.SpringFestival]: {
+                type: FestivalType.SpringFestival,
+                dates: [
+                    '2026-02-15',
+                    '2026-02-16',
+                    '2026-02-17',
+                    '2026-02-18',
+                    '2026-02-19',
+                    '2026-02-20',
+                    '2026-02-21',
+                    '2026-02-22',
+                    '2026-02-23',
+                ],
+                adjustedDays: [
+                    '2026-02-14', // 2月14日（周六）上班
+                    '2026-02-28', // 2月28日（周六）上班
+                ],
+            },
+            [FestivalType.TombSweepingDay]: {
+                type: FestivalType.TombSweepingDay,
+                dates: ['2026-04-04', '2026-04-05', '2026-04-06'],
+            },
+            [FestivalType.LaborDay]: {
+                type: FestivalType.LaborDay,
+                dates: ['2026-05-01', '2026-05-02', '2026-05-03', '2026-05-04', '2026-05-05'],
+                adjustedDays: ['2026-05-09'], // 5月9日（周六）上班
+            },
+            [FestivalType.DragonBoatFestival]: {
+                type: FestivalType.DragonBoatFestival,
+                dates: ['2026-06-22', '2026-06-23', '2026-06-24'],
+            },
+            [FestivalType.MidAutumnFestival]: {
+                type: FestivalType.MidAutumnFestival,
+                dates: ['2026-09-29', '2026-09-30', '2026-10-01'],
+            },
+            [FestivalType.NationalDay]: {
+                type: FestivalType.NationalDay,
+                dates: [
+                    '2026-10-01',
+                    '2026-10-02',
+                    '2026-10-03',
+                    '2026-10-04',
+                    '2026-10-05',
+                    '2026-10-06',
+                    '2026-10-07',
+                ],
+                adjustedDays: [
+                    '2026-10-08', // 10月8日（周日）上班
+                ],
+            },
+        },
+        bigWeekWorkdays: [
+            ['2026-01-17', '2026-01-31'],
+            ['2026-02-07', '2026-02-21'],
+            ['2026-03-07', '2026-03-21'],
+            ['2026-04-11', '2026-04-25'],
+            ['2026-05-16', '2026-05-30'], // ?
+            ['2026-06-13', '2026-06-27'],
+            ['2026-07-11', '2026-07-25'],
+            ['2026-08-08', '2026-08-22'],
+            ['2026-09-05', '2026-09-19'],
+            ['2026-10-17', '2026-10-31'],
+            ['2026-11-14', '2026-11-28'],
+            ['2026-12-12', '2026-12-26'],
+        ],
+    },
+};
+/**
+ * 判断是否为周末（周六或周日）
+ */
+function isWeekend(date) {
+    const day = date.getDay();
+    return day === 0 || day === 6;
+}
+/**
+ * 格式化日期为 YYYY-MM-DD
+ */
+function formatDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+/**
+ * 判断是否为工作日
+ */
+function isWorkday(date, year) {
+    const dateStr = formatDate(date);
+    const yearConfig = exports.HOLIDAYS[year];
+    if (!yearConfig) {
+        return !isWeekend(date);
+    }
+    // 检查是否在法定节假日中
+    for (const festival of Object.values(yearConfig.festivals)) {
+        if (festival.dates.includes(dateStr)) {
+            return false;
+        }
+        // 检查是否是该节日的调休工作日
+        if (festival.adjustedDays?.includes(dateStr)) {
+            return true;
+        }
+    }
+    // 检查是否在大小周工作日中
+    for (const workdays of yearConfig.bigWeekWorkdays) {
+        if (workdays.includes(dateStr)) {
+            return true;
+        }
+    }
+    return !isWeekend(date);
+}
+/**
+ * 计算工作日
+ * @param year 年份
+ * @returns 应计工作日天数
+ */
+function calculateExpectedWorkdays(year) {
+    const yearNum = parseInt(year);
+    const currentYear = new Date().getFullYear();
+    const currentDate = new Date();
+    let endDate;
+    if (yearNum < currentYear) {
+        // 历史年份，计算全年
+        endDate = new Date(yearNum, 11, 31);
+    }
+    else if (yearNum === currentYear) {
+        // 当前年份，计算到今天
+        endDate = currentDate;
+    }
+    else {
+        // 未来年份，返回0
+        return 0;
+    }
+    const startDate = new Date(yearNum, 0, 1);
+    let workdays = 0;
+    // 遍历每一天
+    for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+        if (isWorkday(d, year)) {
+            workdays++;
+        }
+    }
+    return workdays;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ApiService } from './services/api.service';
+export { BusinessService } from './services/business.service';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,23 @@
+"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 });
+exports.BusinessService = exports.ApiService = void 0;
+// 导出API服务和类型定义
+var api_service_1 = require("./services/api.service");
+Object.defineProperty(exports, "ApiService", { enumerable: true, get: function () { return api_service_1.ApiService; } });
+var business_service_1 = require("./services/business.service");
+Object.defineProperty(exports, "BusinessService", { enumerable: true, get: function () { return business_service_1.BusinessService; } });
+__exportStar(require("./types"), exports);