trackswap 0.0.1 → 0.0.2

package/dist/FIT/mesg.js

@@ -0,0 +1,208 @@
+import { types, encodedStrlen } from "./types/index.js";
+import { MesgNum } from "./types/mesg_num.js";
+const mesgDefns = {
+    file_id: {
+        mesgNum: MesgNum.FILE_ID,
+        fieldDefns: [
+            { name: "type", number: 0, type: "enum_file" },
+            { name: "time_created", number: 4, type: "date_time" },
+        ],
+    },
+    session: {
+        mesgNum: MesgNum.SESSION,
+        fieldDefns: [
+            { name: "timestamp", number: 253, type: "date_time" },
+            { name: "start_time", number: 2, type: "date_time" },
+            { name: "total_elapsed_time", number: 7, type: "seconds" },
+            { name: "total_timer_time", number: 8, type: "seconds" },
+            { name: "start_position_lat", number: 3, type: "semicircles" },
+            { name: "start_position_long", number: 4, type: "semicircles" },
+            { name: "total_distance", number: 9, type: "distance" },
+            { name: "total_ascent", number: 21, type: "uint16" },
+            { name: "total_descent", number: 22, type: "uint16" },
+            { name: "sport", number: 5, type: "enum_sport" },
+            { name: "sub_sport", number: 6, type: "enum_sub_sport" },
+            { name: "first_lap_index", number: 11, type: "uint16" },
+            { name: "num_laps", number: 26, type: "uint16" },
+        ],
+    },
+    lap: {
+        mesgNum: MesgNum.LAP,
+        fieldDefns: [
+            { name: "timestamp", number: 253, type: "date_time" },
+            { name: "start_time", number: 2, type: "date_time" },
+            { name: "start_position_lat", number: 3, type: "semicircles" },
+            { name: "start_position_long", number: 4, type: "semicircles" },
+            { name: "end_position_lat", number: 5, type: "semicircles" },
+            { name: "end_position_long", number: 6, type: "semicircles" },
+            { name: "total_elapsed_time", number: 7, type: "seconds" },
+            { name: "total_timer_time", number: 8, type: "seconds" },
+            { name: "total_distance", number: 9, type: "distance" },
+            { name: "total_ascent", number: 21, type: "uint16" },
+            { name: "total_descent", number: 22, type: "uint16" },
+        ],
+    },
+    record: {
+        mesgNum: MesgNum.RECORD,
+        fieldDefns: [
+            { name: "timestamp", number: 253, type: "date_time" },
+            { name: "position_lat", number: 0, type: "semicircles" },
+            { name: "position_long", number: 1, type: "semicircles" },
+            { name: "altitude", number: 2, type: "altitude" },
+            { name: "distance", number: 5, type: "distance" },
+            { name: "heart_rate", number: 3, type: "uint8" },
+            { name: "cadence", number: 4, type: "uint8" },
+            { name: "speed", number: 6, type: "speed" },
+            { name: "power", number: 7, type: "uint16" },
+        ],
+    },
+    event: {
+        mesgNum: MesgNum.EVENT,
+        fieldDefns: [
+            { name: "timestamp", number: 253, type: "date_time" },
+            { name: "event", number: 0, type: "enum_event" },
+            { name: "event_type", number: 1, type: "enum_event_type" },
+            { name: "event_group", number: 4, type: "uint8" },
+        ],
+    },
+    course: {
+        mesgNum: MesgNum.COURSE,
+        fieldDefns: [
+            { name: "name", number: 5, type: "string" },
+            { name: "sport", number: 4, type: "enum_sport" },
+            { name: "sub_sport", number: 7, type: "enum_sub_sport" },
+        ],
+    },
+    activity: {
+        mesgNum: MesgNum.ACTIVITY,
+        fieldDefns: [
+            { name: "timestamp", number: 253, type: "date_time" },
+            { name: "total_timer_time", number: 0, type: "seconds" },
+            { name: "num_sessions", number: 1, type: "uint16" },
+            { name: "type", number: 2, type: "enum_activity" },
+            { name: "event", number: 3, type: "enum_event" },
+            { name: "event_type", number: 4, type: "enum_event_type" },
+            { name: "local_timestamp", number: 5, type: "date_time" },
+            { name: "event_group", number: 6, type: "uint8" },
+        ],
+    },
+    course_point: {
+        mesgNum: MesgNum.COURSE_POINT,
+        fieldDefns: [
+            { name: "timestamp", number: 1, type: "date_time" },
+            { name: "position_lat", number: 2, type: "semicircles" },
+            { name: "position_long", number: 3, type: "semicircles" },
+            { name: "distance", number: 4, type: "distance" },
+            { name: "type", number: 5, type: "enum_course_point" },
+        ],
+    },
+};
+/**
+ * 将 fieldDefns 和 fieldValues 转换为 fields 对象
+ */
+const fields = (fieldDefns, fieldValues) => {
+    return fieldDefns
+        .map((fieldDefn) => ({ ...fieldDefn, value: fieldValues[fieldDefn.name] }))
+        .filter(({ value }) => value !== undefined);
+};
+export class Mesg {
+    static check(mesgName, mesgNum, fieldDefns, values) {
+        if (mesgNum === undefined) {
+            throw new Error(`Message '${mesgName}' not known`);
+        }
+        if (fieldDefns === undefined) {
+            throw new Error(`Message '${mesgName}' has no field definitions`);
+        }
+        const fieldNames = fieldDefns.map((fieldDefn) => fieldDefn.name);
+        const unknownFields = Object.keys(values).filter((fieldName) => !fieldNames.includes(fieldName));
+        if (unknownFields.length) {
+            throw new Error(`Message '${mesgName}' has no field definitions named '${unknownFields}'`);
+        }
+    }
+    constructor(localNum, mesgName, values) {
+        const mesgDefn = mesgDefns[mesgName];
+        if (!mesgDefn) {
+            throw new Error(`Unknown message type: ${mesgName}`);
+        }
+        const { mesgNum, fieldDefns } = mesgDefn;
+        Mesg.check(mesgName, mesgNum, fieldDefns, values);
+        this.localNum = localNum;
+        this.mesgNum = mesgNum;
+        this.fields = fields(fieldDefns, values);
+    }
+    /**
+     * 获取 defns，并获取了 size
+     */
+    get mesgDefn() {
+        const fieldDefns = this.fields.map(({ number, type, value }) => {
+            const typeInfo = types[type];
+            if (!typeInfo) {
+                throw new Error(`Unknown type: ${type}`);
+            }
+            const { size, baseType } = typeInfo;
+            if (type === "string") {
+                return { number, size: encodedStrlen(value), baseType };
+            }
+            return { number, size, baseType };
+        });
+        return {
+            localNum: this.localNum,
+            mesgNum: this.mesgNum,
+            fieldDefns,
+        };
+    }
+    isSameDefn(mesgDefn) {
+        const isSameFieldDefn = (defn1, defn2) => defn1.number === defn2.number &&
+            defn1.size === defn2.size &&
+            defn1.baseType === defn2.baseType;
+        const areSameFieldDefns = (defns1, defns2) => defns1.length === defns2.length &&
+            defns1.every((defn1, i) => isSameFieldDefn(defn1, defns2[i]));
+        const { localNum, mesgNum, fieldDefns } = this.mesgDefn;
+        return (mesgNum === mesgDefn.mesgNum &&
+            localNum === mesgDefn.localNum &&
+            areSameFieldDefns(fieldDefns, mesgDefn.fieldDefns));
+    }
+    get defnRecord() {
+        const { localNum, mesgNum, fieldDefns } = this.mesgDefn;
+        const recordLen = 6 + 3 * fieldDefns.length;
+        const dv = new DataView(new ArrayBuffer(recordLen));
+        dv.setUint8(0, 0x40 | localNum);
+        dv.setUint8(2, 1); // big endian
+        dv.setUint16(3, mesgNum);
+        dv.setUint8(5, fieldDefns.length);
+        let offset = 6;
+        for (const fieldDefn of fieldDefns) {
+            dv.setUint8(offset++, fieldDefn.number);
+            dv.setUint8(offset++, fieldDefn.size);
+            dv.setUint8(offset++, fieldDefn.baseType);
+        }
+        return dv.buffer;
+    }
+    get dataRecord() {
+        const { fieldDefns } = this.mesgDefn;
+        const recordLen = 1 +
+            fieldDefns.reduce((len, { size }) => len + size, 0);
+        const dv = new DataView(new ArrayBuffer(recordLen));
+        dv.setUint8(0, this.localNum);
+        let offset = 1;
+        for (const { number, type, value } of this.fields) {
+            const typeInfo = types[type];
+            if (!typeInfo) {
+                throw new Error(`Unknown type: ${type}`);
+            }
+            const { size, setValue } = typeInfo;
+            let mappedValue;
+            if ("mapValue" in typeInfo) {
+                mappedValue = typeInfo.mapValue(value);
+            }
+            else {
+                mappedValue = value;
+            }
+            if (setValue) {
+                setValue.call(dv, offset, mappedValue);
+            }
+            offset += size;
+        }
+        return dv.buffer;
+    }
+}

package/dist/FIT/middleware.d.ts

@@ -0,0 +1,48 @@
+import { BaseFITMiddleware } from "./base.js";
+import { FITDecoderMesgs, FITFileType, FITContext } from "./types.js";
+/**
+ * 性能监控中间件
+ */
+export declare class PerformanceMiddleware extends BaseFITMiddleware {
+    name: string;
+    description: string;
+    onParse(buffer: Buffer, context: FITContext): Promise<Buffer>;
+    onExtractMessages(messages: FITDecoderMesgs, context: FITContext): Promise<FITDecoderMesgs>;
+    onStructure(result: Partial<FITFileType>, context: FITContext): Promise<Partial<FITFileType>>;
+    onComplete(result: FITFileType, context: FITContext): Promise<FITFileType>;
+    onError(error: Error, context: FITContext): Promise<void>;
+    private countMessages;
+    private analyzeStructure;
+    private getSummary;
+}
+/**
+ * 数据验证中间件
+ */
+export declare class ValidationMiddleware extends BaseFITMiddleware {
+    name: string;
+    description: string;
+    onComplete(result: FITFileType, context: FITContext): Promise<FITFileType>;
+    private validateFIT;
+}
+/**
+ * 数据清理中间件
+ */
+export declare class DataCleanupMiddleware extends BaseFITMiddleware {
+    name: string;
+    description: string;
+    onStructure(result: Partial<FITFileType>, context: FITContext): Promise<Partial<FITFileType>>;
+    private cleanupData;
+}
+/**
+ * 文件信息提取中间件
+ */
+export declare class FileInfoMiddleware extends BaseFITMiddleware {
+    name: string;
+    description: string;
+    onExtractMessages(messages: FITDecoderMesgs, context: FITContext): Promise<FITDecoderMesgs>;
+    private extractFileInfo;
+}
+/**
+ * 注册所有默认中间件
+ */
+export declare function registerDefaultMiddlewares(decoder: any): Promise<void>;

package/dist/FIT/middleware.js

@@ -0,0 +1,206 @@
+import { BaseFITMiddleware } from "./base.js";
+// ============ 示例中间件 ============
+/**
+ * 性能监控中间件
+ */
+export class PerformanceMiddleware extends BaseFITMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "performance-middleware";
+        this.description = "监控FIT解析性能";
+    }
+    async onParse(buffer, context) {
+        console.log(`🔧 开始解析FIT文件，大小: ${buffer.length} bytes`);
+        return buffer;
+    }
+    async onExtractMessages(messages, context) {
+        const messageCount = this.countMessages(messages);
+        console.log(`📋 消息提取完成，包含 ${messageCount} 条消息`);
+        // 显示消息类型统计
+        const messageTypes = Object.keys(messages).filter((key) => Array.isArray(messages[key]) && messages[key].length > 0);
+        console.log(`   消息类型: ${messageTypes.join(", ")}`);
+        return messages;
+    }
+    async onStructure(result, context) {
+        const structureInfo = this.analyzeStructure(result);
+        console.log(`🏗️ 数据结构化完成: ${structureInfo}`);
+        return result;
+    }
+    async onComplete(result, context) {
+        const performance = context.metadata.get("performance");
+        console.log("⚡ FIT解析性能统计:", performance);
+        // 显示最终结果统计
+        console.log(`✅ 解析完成: ${this.getSummary(result)}`);
+        return result;
+    }
+    async onError(error, context) {
+        console.error(`❌ FIT解析出错: ${error.message}`);
+        console.error(`   错误详情:`, error.stack);
+    }
+    countMessages(messages) {
+        let count = 0;
+        Object.values(messages).forEach((messageArray) => {
+            if (Array.isArray(messageArray)) {
+                count += messageArray.length;
+            }
+        });
+        return count;
+    }
+    analyzeStructure(result) {
+        const parts = [];
+        if (result.sessionMesgs?.length) {
+            parts.push(`${result.sessionMesgs.length} sessions`);
+        }
+        if (result.fileIdMesgs?.length) {
+            parts.push(`文件ID`);
+        }
+        if (result.eventMesgs?.length) {
+            parts.push(`${result.eventMesgs.length} events`);
+        }
+        return parts.join(", ") || "无结构化数据";
+    }
+    getSummary(result) {
+        const parts = [];
+        if (result.sessionMesgs?.length) {
+            parts.push(`${result.sessionMesgs.length}个会话`);
+        }
+        if (result.fileIdMesgs?.length) {
+            const fileId = result.fileIdMesgs[0];
+            parts.push(`类型:${fileId.type}, 厂商:${fileId.manufacturer}`);
+        }
+        return parts.join(", ") || "空结果";
+    }
+}
+/**
+ * 数据验证中间件
+ */
+export class ValidationMiddleware extends BaseFITMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "validation-middleware";
+        this.description = "验证FIT数据的完整性";
+    }
+    async onComplete(result, context) {
+        const errors = this.validateFIT(result);
+        if (errors.length > 0) {
+            console.warn("🚨 FIT验证发现问题:", errors);
+            context.metadata.set("validation-errors", errors);
+            // 将验证错误添加到上下文
+            errors.forEach((error) => context.warnings.push(error));
+        }
+        else {
+            console.log("✅ FIT数据验证通过");
+        }
+        return result;
+    }
+    validateFIT(fit) {
+        const errors = [];
+        // 验证文件ID
+        if (!fit.fileIdMesgs || fit.fileIdMesgs.length === 0) {
+            errors.push("缺少文件ID信息");
+        }
+        else {
+            const fileId = fit.fileIdMesgs[0];
+            if (!fileId.type) {
+                errors.push("文件类型未指定");
+            }
+            if (!fileId.manufacturer) {
+                errors.push("制造商信息缺失");
+            }
+        }
+        // 验证会话数据
+        if (fit.sessionMesgs && fit.sessionMesgs.length > 0) {
+            fit.sessionMesgs.forEach((session, index) => {
+                if (!session.startTime) {
+                    errors.push(`会话 ${index + 1} 缺少开始时间`);
+                }
+                if (!session.timestamp) {
+                    errors.push(`会话 ${index + 1} 缺少结束时间`);
+                }
+                if (session.totalTimerTime === undefined) {
+                    errors.push(`会话 ${index + 1} 缺少计时时间`);
+                }
+            });
+        }
+        return errors;
+    }
+}
+/**
+ * 数据清理中间件
+ */
+export class DataCleanupMiddleware extends BaseFITMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "data-cleanup-middleware";
+        this.description = "清理和优化FIT数据";
+    }
+    async onStructure(result, context) {
+        // 清理空数组和无效数据
+        return this.cleanupData(result);
+    }
+    cleanupData(result) {
+        const cleaned = { ...result };
+        // 移除空数组
+        Object.keys(cleaned).forEach((key) => {
+            const value = cleaned[key];
+            if (Array.isArray(value) && value.length === 0) {
+                delete cleaned[key];
+            }
+        });
+        // 清理会话数据中的无效值
+        if (cleaned.sessionMesgs) {
+            cleaned.sessionMesgs = cleaned.sessionMesgs.filter((session) => session.startTime && session.timestamp);
+        }
+        console.log("🧹 数据清理完成");
+        return cleaned;
+    }
+}
+/**
+ * 文件信息提取中间件
+ */
+export class FileInfoMiddleware extends BaseFITMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "file-info-middleware";
+        this.description = "提取和显示文件基本信息";
+    }
+    async onExtractMessages(messages, context) {
+        this.extractFileInfo(messages, context);
+        return messages;
+    }
+    extractFileInfo(messages, context) {
+        if (messages.fileIdMesgs && messages.fileIdMesgs.length > 0) {
+            const fileId = messages.fileIdMesgs[0];
+            const fileInfo = {
+                type: fileId.type,
+                manufacturer: fileId.manufacturer,
+                product: fileId.product,
+                serialNumber: fileId.serialNumber,
+                timeCreated: fileId.timeCreated,
+            };
+            context.metadata.set("file-info", fileInfo);
+            console.log("📄 文件信息:", {
+                类型: fileInfo.type,
+                制造商: fileInfo.manufacturer,
+                产品: fileInfo.product,
+                序列号: fileInfo.serialNumber,
+                创建时间: fileInfo.timeCreated,
+            });
+        }
+    }
+}
+// ============ 默认中间件注册函数 ============
+/**
+ * 注册所有默认中间件
+ */
+export async function registerDefaultMiddlewares(decoder) {
+    const middlewares = [
+        new PerformanceMiddleware(),
+        new ValidationMiddleware(),
+        new DataCleanupMiddleware(),
+        new FileInfoMiddleware(),
+    ];
+    for (const middleware of middlewares) {
+        await decoder.registerMiddleware(middleware);
+    }
+}

package/dist/FIT/plugins.d.ts

@@ -0,0 +1,26 @@
+import { BaseFITStructurePlugin } from "./base.js";
+import { FITDecoderMesgs, FITFileType, FITContext } from "./types.js";
+/**
+ * Session 数据结构化插件
+ */
+export declare class SessionStructurePlugin extends BaseFITStructurePlugin {
+    name: string;
+    priority: number;
+    structureData(messages: FITDecoderMesgs, context: FITContext): Partial<FITFileType>;
+}
+/**
+ * Course 数据结构化插件
+ */
+export declare class CourseStructurePlugin extends BaseFITStructurePlugin {
+    name: string;
+    priority: number;
+    structureData(messages: FITDecoderMesgs, context: FITContext): Partial<FITFileType>;
+}
+/**
+ * 文件头信息提取插件
+ */
+export declare class FileHeaderPlugin extends BaseFITStructurePlugin {
+    name: string;
+    priority: number;
+    structureData(messages: FITDecoderMesgs, context: FITContext): Partial<FITFileType>;
+}

package/dist/FIT/plugins.js

@@ -0,0 +1,104 @@
+import dayjs from "dayjs";
+import { BaseFITStructurePlugin } from "./base.js";
+/**
+ * Session 数据结构化插件
+ */
+export class SessionStructurePlugin extends BaseFITStructurePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = "SessionStructurePlugin";
+        this.priority = 10;
+    }
+    structureData(messages, context) {
+        const { sessionMesgs, lapMesgs, recordMesgs } = messages;
+        if (!sessionMesgs?.length) {
+            console.warn("未发现结构化 session，数据结构不完整");
+            return {};
+        }
+        // 将每个 Session 的 Lap 和 Record 关联起来
+        const sessionStructureMesgs = sessionMesgs.map((session) => {
+            const sessionStartTime = dayjs(session.startTime).valueOf();
+            const sessionEndTime = dayjs(session.timestamp).valueOf();
+            // 找出属于当前 Session 的 Laps
+            const sessionLaps = lapMesgs?.filter((lap) => {
+                const lapStartTime = dayjs(lap.startTime).valueOf();
+                const lapEndTime = dayjs(lap.timestamp).valueOf();
+                return (lapStartTime >= sessionStartTime && lapEndTime <= sessionEndTime);
+            }) || [];
+            console.log("当前 session 下共有 Lap", sessionLaps.length);
+            // 为每个 Lap 找出对应的 Records
+            const lapsWithRecords = sessionLaps.map((lap) => {
+                const lapStartTime = dayjs(lap.startTime).valueOf();
+                const lapEndTime = dayjs(lap.timestamp).valueOf();
+                const lapRecords = recordMesgs?.filter((record) => {
+                    const recordTime = dayjs(record.timestamp).valueOf();
+                    return recordTime >= lapStartTime && recordTime <= lapEndTime;
+                }) || [];
+                console.log("找到当前 Lap 下的 records", lapRecords.length, recordMesgs?.length, dayjs(lapStartTime).format("YYYY-MM-DD HH:mm:ss"), dayjs(lapEndTime).format("YYYY-MM-DD HH:mm:ss"));
+                return { ...lap, recordMesgs: lapRecords };
+            });
+            // 返回重新组织后的 Session
+            return { ...session, lapMesgs: lapsWithRecords };
+        });
+        return {
+            sessionMesgs: sessionStructureMesgs,
+        };
+    }
+}
+/**
+ * Course 数据结构化插件
+ */
+export class CourseStructurePlugin extends BaseFITStructurePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = "CourseStructurePlugin";
+        this.priority = 10;
+    }
+    structureData(messages, context) {
+        const { courseMesgs, lapMesgs, recordMesgs } = messages;
+        if (!courseMesgs?.length) {
+            return {};
+        }
+        // 时间容错，默认2秒
+        const TIME_TOLERANCE = 2000;
+        const courseStructureMesgs = courseMesgs.map((course) => {
+            const lapsWithRecords = lapMesgs?.map((lap) => {
+                const lapStartTime = dayjs(lap.startTime).valueOf();
+                const lapEndTime = dayjs(lap.timestamp).valueOf();
+                // 添加时间容错，因为时间戳可能不太准确
+                const lapRecords = recordMesgs?.filter((record) => {
+                    const recordTime = dayjs(record.timestamp).valueOf();
+                    return (recordTime >= lapStartTime - TIME_TOLERANCE &&
+                        recordTime <= lapEndTime + TIME_TOLERANCE);
+                }) || [];
+                return { ...lap, recordMesgs: lapRecords };
+            }) || [];
+            return { ...course, lapMesgs: lapsWithRecords };
+        });
+        return {
+            courseMesgs: courseStructureMesgs,
+        };
+    }
+}
+/**
+ * 文件头信息提取插件
+ */
+export class FileHeaderPlugin extends BaseFITStructurePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = "FileHeaderPlugin";
+        this.priority = 1; // 高优先级，先执行
+    }
+    structureData(messages, context) {
+        const { fileIdMesgs } = messages;
+        if (fileIdMesgs?.length && fileIdMesgs[0]) {
+            const fileId = fileIdMesgs[0];
+            context.fileHeader = {
+                type: fileId.type,
+                manufacturer: fileId.manufacturer,
+                product: fileId.product,
+            };
+        }
+        return {};
+    }
+}

package/dist/FIT/processor.d.ts

@@ -0,0 +1,58 @@
+import { IFITMessageConverter, IFITStructurePlugin } from "./base.js";
+import { FITContext } from "./types.js";
+/**
+ * FIT 流水线阶段
+ */
+export declare enum FITPipelineStage {
+    PARSE = "parse",
+    EXTRACT = "extract",
+    STRUCTURE = "structure",
+    COMPLETE = "complete"
+}
+/**
+ * FIT 流水线处理器接口
+ */
+export interface IFITPipelineProcessor {
+    stage: FITPipelineStage;
+    process(context: FITContext): Promise<FITContext>;
+}
+/**
+ * Parse处理器 - 解析二进制FIT数据为消息
+ */
+export declare class ParseProcessor implements IFITPipelineProcessor {
+    stage: FITPipelineStage;
+    process(context: FITContext): Promise<FITContext>;
+    /**
+     * 使用 FIT SDK 解析二进制数据
+     */
+    private parseWithFitSDK;
+}
+/**
+ * Extract处理器 - 提取和转换消息
+ */
+export declare class ExtractProcessor implements IFITPipelineProcessor {
+    private getConverters;
+    stage: FITPipelineStage;
+    constructor(getConverters: (messageType: string) => IFITMessageConverter[]);
+    process(context: FITContext): Promise<FITContext>;
+}
+/**
+ * Structure处理器 - 数据结构化
+ */
+export declare class StructureProcessor implements IFITPipelineProcessor {
+    private getStructurePlugins;
+    stage: FITPipelineStage;
+    constructor(getStructurePlugins: () => IFITStructurePlugin[]);
+    process(context: FITContext): Promise<FITContext>;
+}
+/**
+ * Complete处理器 - 最终处理和清理
+ */
+export declare class CompleteProcessor implements IFITPipelineProcessor {
+    stage: FITPipelineStage;
+    process(context: FITContext): Promise<FITContext>;
+    /**
+     * 计算消息总数
+     */
+    private countTotalMessages;
+}