wechaty-puppet-padplus2 3.1.2

package/dist/esm/server/service/config/index.js

@@ -0,0 +1,7 @@
+import o from "dotenv";
+
+o.config();
+
+const e = process.env.PUPPET_PADPLUS_BASE_URL, t = process.env.BASE_PORT, p = process.env.DEVICE_NAME || "my-device-name", s = "http://localhost:9999/api", c = "http://localhost:8848", n = `http://${e}:${t}/api`, r = 3e4;
+
+export { s as BASE_URL, c as BASE_URL_849, n as BASE_URL_857, p as DeviceName, r as TIME_OUT };

package/dist/esm/server/service/index.js

@@ -0,0 +1,30 @@
+import e from "./request/index.js";
+
+import { TIME_OUT as s, BASE_URL as t, BASE_URL_849 as n, BASE_URL_857 as r } from "./config/index.js";
+
+new e({
+  baseURL: t,
+  timeout: s,
+  interceptors: {
+    requestSuccessFn: e => e,
+    responseSuccessFn: e => e
+  }
+}), new e({
+  baseURL: n,
+  timeout: s,
+  interceptors: {
+    requestSuccessFn: e => e,
+    responseSuccessFn: e => e
+  }
+});
+
+const c = new e({
+  baseURL: r,
+  timeout: s,
+  interceptors: {
+    requestSuccessFn: e => e,
+    responseSuccessFn: e => e
+  }
+});
+
+export { c as SyyyRequest };

package/dist/esm/server/service/request/index.js

@@ -0,0 +1,47 @@
+import e from "axios";
+
+class SyRequest {
+  instance;
+  constructor(s) {
+    this.instance = e.create(s), this.instance.interceptors.request.use((e => e), (e => e)), 
+    this.instance.interceptors.response.use((e => e.data), (e => e)), this.instance.interceptors.request.use(s.interceptors?.requestSuccessFn, s.interceptors?.requestFailFn), 
+    this.instance.interceptors.response.use(s.interceptors?.responseSuccessFn, s.interceptors?.responseFailFn);
+  }
+  request(e) {
+    return e.interceptors?.requestSuccessFn && (e = e.interceptors.requestSuccessFn(e)), 
+    new Promise(((s, t) => {
+      this.instance.request(e).then((t => {
+        e.interceptors?.responseSuccessFn && (t = e.interceptors.responseSuccessFn(t)), 
+        s(t);
+      })).catch((e => {
+        t(e);
+      }));
+    }));
+  }
+  get(e) {
+    return this.request({
+      method: "GET",
+      ...e
+    });
+  }
+  post(e) {
+    return this.request({
+      method: "POST",
+      ...e
+    });
+  }
+  patch(e) {
+    return this.request({
+      method: "PATCH",
+      ...e
+    });
+  }
+  delete(e) {
+    return this.request({
+      method: "DELETE",
+      ...e
+    });
+  }
+}
+
+export { SyRequest as default };

package/dist/esm/server/service/utils/polling.js

@@ -0,0 +1,24 @@
+class Polling {
+  isPolling;
+  constructor() {
+    this.isPolling = !0;
+  }
+  async poll(i, l) {
+    for (;this.isPolling; ) {
+      try {
+        await l();
+      } catch (i) {
+        console.error(i);
+      }
+      await new Promise((l => setTimeout(l, i)));
+    }
+  }
+  stop() {
+    this.isPolling = !1;
+  }
+  start() {
+    this.isPolling = !0;
+  }
+}
+
+export { Polling };

package/dist/esm/server/utils/PromiseUtils.js

@@ -0,0 +1,19 @@
+class PromiseCallback {
+  _resolve;
+  _reject;
+  _timeoutId;
+  constructor(t, e, i) {
+    this._resolve = t, this._reject = e, this._timeoutId = i;
+  }
+  resolve(t) {
+    this._resolve(t), this._invalidateTimeout();
+  }
+  reject(error) {
+    this._reject(error), this._invalidateTimeout();
+  }
+  _invalidateTimeout() {
+    void 0 !== this._timeoutId && (clearTimeout(this._timeoutId), this._timeoutId = void 0);
+  }
+}
+
+export { PromiseCallback };

package/dist/esm/server/utils/SerialExecutor.js

@@ -0,0 +1,41 @@
+import { PromiseCallback as e } from "./PromiseUtils.js";
+
+class SerialJob {
+  type;
+  func;
+  promiseCallback;
+  constructor(e, t, s) {
+    this.func = e, this.promiseCallback = t, this.type = s;
+  }
+}
+
+class SerialExecutor {
+  _jobs;
+  _executing;
+  constructor() {
+    this._jobs = [], this._executing = !1;
+  }
+  execute(t, s) {
+    return new Promise(((i, c) => {
+      this._jobs.push(new SerialJob(t, new e(i, c), s)), this._executeNextJob();
+    }));
+  }
+  clear(e) {
+    this._jobs = this._jobs.filter((t => !!e && t.type !== e));
+  }
+  _executeNextJob() {
+    if (this._executing) {
+      return;
+    }
+    const e = this._jobs.shift();
+    e && (this._executing = !0, e.func().then((t => {
+      e.promiseCallback.resolve(t);
+    })).catch((t => {
+      e.promiseCallback.reject(t);
+    })).finally((() => {
+      this._executing = !1, this._executeNextJob();
+    })));
+  }
+}
+
+export { SerialExecutor };

package/dist/esm/server/utils/Utils.js

@@ -0,0 +1,7 @@
+import r from "cuid";
+
+function e() {
+  return r().replace(/-/g, "");
+}
+
+export { e as genIdempotentId };

package/dist/esm/server/utils/xml-to-json.js

@@ -0,0 +1,18 @@
+import { parseString as n, Builder as t } from "xml2js";
+
+import { log as e } from "wechaty-puppet";
+
+async function r(t) {
+  const r = t.indexOf("<");
+  return 0 !== r && (t = t.substring(r, t.length)), new Promise((r => {
+    n(t, {
+      explicitArray: !1
+    }, ((n, t) => (n && 0 !== Object.keys(n).length && e.warn(JSON.stringify(n)), r(t))));
+  }));
+}
+
+async function i(n) {
+  return (new t).buildObject(n);
+}
+
+export { i as jsonToXml, r as xmlToJson };

package/dist/types/cleanup.d.ts

@@ -0,0 +1,4 @@
+import type * as PUPPET from "wechaty-puppet";
+export declare function addRunningPuppet(puppet: PUPPET.Puppet): void;
+export declare function removeRunningPuppet(puppet: PUPPET.Puppet): void;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/types/config.d.ts

@@ -0,0 +1,9 @@
+import { FileBox } from 'file-box';
+import { log } from 'wechaty-puppet';
+
+declare const VERSION: string;
+declare const NAME: string;
+declare const CHATIE_OFFICIAL_ACCOUNT_QRCODE = "http://weixin.qq.com/r/qymXj7DEO_1ErfTs93y5";
+declare function qrCodeForChatie(): FileBox;
+export { CHATIE_OFFICIAL_ACCOUNT_QRCODE, log, NAME, qrCodeForChatie, VERSION };
+//# sourceMappingURL=config.d.ts.map

package/dist/types/mock/cache-manager.d.ts

@@ -0,0 +1,55 @@
+import type * as PUPPET from "wechaty-puppet";
+export type RoomMemberMap = {
+    [contactId: string]: any;
+};
+export declare class CacheManager {
+    private readonly _userName;
+    private _messageCache?;
+    private _messageRevokeCache?;
+    private _contactCache?;
+    private _contactSearchCache?;
+    private _contactStrangerAliasCache?;
+    private _roomCache?;
+    private _roomMemberCache?;
+    private _roomInvitationCache?;
+    private _friendshipCache?;
+    private _labelList?;
+    constructor(userName: string);
+    init(): Promise<void>;
+    close(): Promise<void>;
+    getMessage(messageId: string): Promise<any | undefined>;
+    setMessage(messageId: string, payload: any): Promise<void>;
+    hasMessage(messageId: string): Promise<boolean>;
+    getMessageRevokeInfo(messageId: string): Promise<any | undefined>;
+    setMessageRevokeInfo(messageId: string, messageSendResult: any): Promise<void>;
+    getContact(contactId: string): Promise<any | undefined>;
+    setContact(contactId: string, payload: any): Promise<void>;
+    deleteContact(contactId: string): Promise<void>;
+    getContactIds(): Promise<string[]>;
+    getAllContacts(): Promise<any[]>;
+    hasContact(contactId: string): Promise<boolean>;
+    getContactCount(): Promise<number>;
+    getContactSearch(id: string): Promise<any | undefined>;
+    setContactSearch(id: string, payload: any): Promise<void>;
+    hasContactSearch(id: string): Promise<boolean>;
+    getContactStrangerAlias(encryptedUserName: string): Promise<string | undefined>;
+    setContactStrangerAlias(encryptedUserName: string, alias: string): Promise<void>;
+    deleteContactStrangerAlias(encryptedUserName: string): Promise<void>;
+    getRoom(roomId: string): Promise<any | undefined>;
+    setRoom(roomId: string, payload: any): Promise<void>;
+    deleteRoom(roomId: string): Promise<void>;
+    getRoomIds(): Promise<string[]>;
+    getRoomCount(): Promise<number>;
+    hasRoom(roomId: string): Promise<boolean>;
+    getRoomMember(roomId: string): Promise<RoomMemberMap | undefined>;
+    setRoomMember(roomId: string, payload: RoomMemberMap): Promise<void>;
+    deleteRoomMember(roomId: string): Promise<void>;
+    getRoomInvitation(messageId: string): Promise<PUPPET.payloads.RoomInvitation | undefined>;
+    setRoomInvitation(messageId: string, payload: PUPPET.payloads.RoomInvitation): Promise<void>;
+    deleteRoomInvitation(messageId: string): Promise<void>;
+    getFriendshipRawPayload(id: string): Promise<PUPPET.payloads.Friendship | undefined>;
+    setFriendshipRawPayload(id: string, payload: PUPPET.payloads.Friendship): Promise<void>;
+    getLabelList(): any[] | undefined;
+    setLabelList(labelList: any[]): void;
+}
+//# sourceMappingURL=cache-manager.d.ts.map

package/dist/types/mock/events/event-friendship.d.ts

@@ -0,0 +1,5 @@
+import { EventPayload } from './event.js';
+import * as PUPPET from "wechaty-puppet";
+declare const _default: (_puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-friendship.d.ts.map

package/dist/types/mock/events/event-message.d.ts

@@ -0,0 +1,5 @@
+import { EventPayload } from './event.js';
+import type * as PUPPET from "wechaty-puppet";
+declare const _default: (_puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-message.d.ts.map

package/dist/types/mock/events/event-room-invite.d.ts

@@ -0,0 +1,5 @@
+import { EventPayload } from './event.js';
+import type * as PUPPET from "wechaty-puppet";
+declare const _default: (_puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-room-invite.d.ts.map

package/dist/types/mock/events/event-room-join.d.ts

@@ -0,0 +1,5 @@
+import { EventPayload } from './event.js';
+import type * as PUPPET from "wechaty-puppet";
+declare const _default: (puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-room-join.d.ts.map

package/dist/types/mock/events/event-room-leave.d.ts

@@ -0,0 +1,7 @@
+import { EventPayload } from './event.js';
+import type * as PUPPET from "wechaty-puppet";
+export declare function removeRoomLeaveDebounce(roomId: string, removeeId: string): void;
+export declare function isRoomLeaveDebouncing(roomId: string, removeeId: string): boolean;
+declare const _default: (puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-room-leave.d.ts.map

package/dist/types/mock/events/event-room-topic.d.ts

@@ -0,0 +1,5 @@
+import { EventPayload } from './event.js';
+import type * as PUPPET from "wechaty-puppet";
+declare const _default: (puppet: PUPPET.Puppet, message: any) => Promise<EventPayload>;
+export default _default;
+//# sourceMappingURL=event-room-topic.d.ts.map

package/dist/types/mock/events/event.d.ts

@@ -0,0 +1,28 @@
+import { Puppet } from 'wechaty-puppet';
+
+import type * as PUPPET from "wechaty-puppet";
+export declare enum EventType {
+    Message = 0,
+    Friendship = 1,
+    RoomInvite = 2,
+    RoomJoin = 3,
+    RoomLeave = 4,
+    RoomTopic = 5
+}
+export interface EventPayloadSpec {
+    [EventType.Message]: any;
+    [EventType.Friendship]: PUPPET.payloads.Friendship;
+    [EventType.RoomInvite]: PUPPET.payloads.RoomInvitation;
+    [EventType.RoomJoin]: PUPPET.payloads.EventRoomJoin;
+    [EventType.RoomLeave]: PUPPET.payloads.EventRoomLeave;
+    [EventType.RoomTopic]: PUPPET.payloads.EventRoomTopic;
+}
+export interface Event<T extends keyof EventPayloadSpec> {
+    type: T;
+    payload: EventPayloadSpec[T];
+}
+export type EventPayload = EventPayloadSpec[keyof EventPayloadSpec] | null;
+export type EventParserHandler = (puppet: Puppet, message: any) => Promise<EventPayload>;
+export declare function addEventParser(eventType: EventType, parser: EventParserHandler): void;
+export declare function parseEvent(puppet: Puppet, message: any): Promise<Event<any>>;
+//# sourceMappingURL=event.d.ts.map

package/dist/types/mock/events/mod.d.ts

@@ -0,0 +1,4 @@
+import { EventType, parseEvent } from './event.js';
+
+export { parseEvent, EventType };
+//# sourceMappingURL=mod.d.ts.map

package/dist/types/mock/messages/message-appmsg.d.ts

@@ -0,0 +1,57 @@
+export declare enum AppMessageType {
+    Text = 1,
+    Img = 2,
+    Audio = 3,
+    Video = 4,
+    Url = 5,
+    Attach = 6,
+    Open = 7,
+    Emoji = 8,
+    VoiceRemind = 9,
+    ScanGood = 10,
+    Good = 13,
+    Emotion = 15,
+    CardTicket = 16,
+    RealtimeShareLocation = 17,
+    ChatHistory = 19,
+    MiniProgram = 33,
+    MiniProgramApp = 36,
+    GroupNote = 53,
+    ReferMsg = 57,
+    Transfers = 2000,
+    RedEnvelopes = 2001,
+    ReaderType = 100001
+}
+export interface AppAttachPayload {
+    totallen?: number;
+    attachid?: string;
+    emoticonmd5?: string;
+    fileext?: string;
+    cdnattachurl?: string;
+    aeskey?: string;
+    cdnthumbaeskey?: string;
+    encryver?: number;
+    islargefilemsg: number;
+}
+export interface ReferMsgPayload {
+    type: string;
+    svrid: string;
+    fromusr: string;
+    chatusr: string;
+    displayname: string;
+    content: string;
+}
+export interface AppMessagePayload {
+    des?: string;
+    thumburl?: string;
+    title: string;
+    url: string;
+    appattach?: AppAttachPayload;
+    type: AppMessageType;
+    md5?: string;
+    fromusername?: string;
+    recorditem?: string;
+    refermsg?: ReferMsgPayload;
+}
+export declare function parseAppmsgMessagePayload(messageContent: string): Promise<AppMessagePayload>;
+//# sourceMappingURL=message-appmsg.d.ts.map

package/dist/types/mock/messages/message-emotion.d.ts

@@ -0,0 +1,12 @@
+export interface EmojiMessagePayload {
+    type: number;
+    len: number;
+    md5: string;
+    cdnurl: string;
+    width: number;
+    height: number;
+    gameext?: string;
+}
+export declare function parseEmotionMessagePayload(message: any): Promise<EmojiMessagePayload>;
+export declare function generateEmotionPayload(emojiMessagePayload: EmojiMessagePayload): string;
+//# sourceMappingURL=message-emotion.d.ts.map

package/dist/types/mock/messages/message-miniprogram.d.ts

@@ -0,0 +1,3 @@
+import type * as PUPPET from "wechaty-puppet";
+export declare function parseMiniProgramMessagePayload(rawPayload: any): Promise<PUPPET.payloads.MiniProgram>;
+//# sourceMappingURL=message-miniprogram.d.ts.map

package/dist/types/mock/messages/message-sysmsg.d.ts

@@ -0,0 +1,18 @@
+import { PatMessagePayload } from './sysmsg/message-pat';
+import { SysmsgTemplateMessagePayload } from './sysmsg/message-sysmsgtemplate';
+import { TodoMessagePayload } from './sysmsg/message-todo.js';
+import { RevokeMsgMessagePayload } from './sysmsg/message-revokemsg';
+import type * as PadPlus from "../../server/map/index.js";
+type SysMsgType = "pat" | "sysmsgtemplate" | "roomtoolstips" | "revokemsg";
+type SysMsgPayload = PatMessagePayload | SysmsgTemplateMessagePayload | TodoMessagePayload | RevokeMsgMessagePayload;
+export interface SysmsgMessagePayload {
+    type: SysMsgType;
+    payload: SysMsgPayload;
+}
+export declare function parseSysmsgMessagePayload(message: PadPlus.Message.AsObject): Promise<SysmsgMessagePayload | null>;
+export declare function parseSysmsgPatMessagePayload(message: PadPlus.Message.AsObject): Promise<PatMessagePayload | null>;
+export declare function parseSysmsgSysmsgTemplateMessagePayload(message: PadPlus.Message.AsObject): Promise<SysmsgTemplateMessagePayload | null>;
+export declare function parseSysmsgTodoMessagePayload(message: PadPlus.Message.AsObject): Promise<TodoMessagePayload | null>;
+export declare function parseSysmsgRevokeMsgMessagePayload(message: PadPlus.Message.AsObject): Promise<RevokeMsgMessagePayload | null>;
+export {};
+//# sourceMappingURL=message-sysmsg.d.ts.map

package/dist/types/mock/messages/sysmsg/message-pat.d.ts

@@ -0,0 +1,14 @@
+export interface PatXmlSchema {
+    fromusername: string;
+    chatusername: string;
+    pattedusername: string;
+    template: string;
+}
+export interface PatMessagePayload {
+    fromUserName: string;
+    chatUserName: string;
+    pattedUserName: string;
+    template: string;
+}
+export declare function parsePatMessagePayload(patXml: PatXmlSchema): Promise<PatMessagePayload>;
+//# sourceMappingURL=message-pat.d.ts.map

package/dist/types/mock/messages/sysmsg/message-revokemsg.d.ts

@@ -0,0 +1,19 @@
+import type * as PUPPET from "wechaty-puppet";
+export interface RevokeMsgXmlSchema {
+    session: string;
+    msgid: string;
+    newmsgid: string;
+    replacemsg: string;
+}
+export type RevokeMsgType = "You" | "Other";
+export interface RevokeMsgMessagePayload {
+    content: string;
+    operatorNickName?: string;
+    originalMessageId: string;
+    session: string;
+    type: RevokeMsgType;
+}
+export declare function parseRevokeMsgMessagePayload(revokeMsgXmlSchema: RevokeMsgXmlSchema): Promise<RevokeMsgMessagePayload>;
+export declare function getRevokeOriginalMessage(puppet: PUPPET.Puppet, revokemsgPayload: RevokeMsgMessagePayload): Promise<PUPPET.payloads.Message | null>;
+export declare function getRevokeOperatorIdForRoomMessage(puppet: PUPPET.Puppet, revokemsgPayload: RevokeMsgMessagePayload): Promise<string | null>;
+//# sourceMappingURL=message-revokemsg.d.ts.map

package/dist/types/mock/messages/sysmsg/message-sysmsgtemplate.d.ts

@@ -0,0 +1,60 @@
+import { Runner } from '../../utils/runner.js';
+
+export interface SysmsgTemplateXmlSchema {
+    content_template: {
+        $: {
+            type: string;
+        };
+        plain: string;
+        template: string;
+        link_list: {
+            link: [
+                {
+                    $: {
+                        name: string;
+                        type: string;
+                        hidden?: string;
+                    };
+                    memberlist?: {
+                        member: [
+                            {
+                                username?: string;
+                                nickname: string;
+                            }
+                        ];
+                    };
+                    separator?: string;
+                    title?: string;
+                    usernamelist?: {
+                        username: string[];
+                    };
+                }
+            ];
+        };
+    };
+}
+export interface SysmsgTemplateLinkMember {
+    userName?: string;
+    nickName: string;
+}
+export type SysmsgTemplateLinkProfile = Array<SysmsgTemplateLinkMember>;
+export interface SysmsgTemplateLinkRevoke {
+    title: string;
+    userNameList: string[];
+}
+export type SysmsgTemplateLinkType = "link_profile" | "link_revoke";
+export type SysmsgTemplateLinkPayload = SysmsgTemplateLinkProfile | SysmsgTemplateLinkRevoke;
+export interface SysmsgTemplateLink {
+    name: string;
+    payload: SysmsgTemplateLinkPayload;
+    type: SysmsgTemplateLinkType;
+}
+export interface SysmsgTemplateMessagePayload {
+    template: string;
+    templateLinkList: Array<SysmsgTemplateLink>;
+}
+export declare function parseSysmsgTemplateMessagePayload(sysmsgTemplateXml: SysmsgTemplateXmlSchema): Promise<SysmsgTemplateMessagePayload>;
+export type SysmsgTemplateHandler<T> = (templateLinkList: SysmsgTemplateLink[], matchedRegexIndex: number) => Promise<T>;
+export declare function parseSysmsgTemplate<T>(sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>): Promise<T | null>;
+export declare function createSysmsgTemplateRunner<T>(sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>): Runner<T>;
+//# sourceMappingURL=message-sysmsgtemplate.d.ts.map

package/dist/types/mock/messages/sysmsg/message-todo.d.ts

@@ -0,0 +1,31 @@
+export interface TodoXmlSchema {
+    op: string;
+    todoid: string;
+    username: string;
+    path: string;
+    time: number;
+    custominfo: string;
+    title: string;
+    creator: string;
+    related_msgid: string;
+    manager: string;
+    nreply: number;
+    scene: string;
+    oper: string;
+    sharekey: string;
+    sharename: string;
+    template?: string;
+}
+export interface TodoMessagePayload {
+    id: string;
+    creatorUserName: string;
+    operatorUserName: string;
+    numberOfReply: number;
+    appId: string;
+    path: string;
+    relatedMessageId: string;
+    title: string;
+    template?: string;
+}
+export declare function parseTodoMessagePayload(todoXml: TodoXmlSchema): Promise<TodoMessagePayload>;
+//# sourceMappingURL=message-todo.d.ts.map

package/dist/types/mock/schema-mapper/contact.d.ts

@@ -0,0 +1,4 @@
+import type * as PadPlus from "../../server/map/index.js";
+import * as PUPPET from "wechaty-puppet";
+export declare function padPlusContactToWechaty(contact: PadPlus.Contact.AsObject): PUPPET.payloads.Contact;
+//# sourceMappingURL=contact.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-appmsg.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser.js';
+
+export declare const appMsgParser: MessageParser;
+//# sourceMappingURL=message-parser-appmsg.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-refermsg.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser.js';
+
+export declare const referMsgParser: MessageParser;
+//# sourceMappingURL=message-parser-refermsg.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-room.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser.js';
+
+export declare const roomParser: MessageParser;
+//# sourceMappingURL=message-parser-room.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-single-chat.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser';
+
+export declare const singleChatParser: MessageParser;
+//# sourceMappingURL=message-parser-single-chat.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-sysmsg.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser.js';
+
+export declare const sysmsgParser: MessageParser;
+//# sourceMappingURL=message-parser-sysmsg.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser-type.d.ts

@@ -0,0 +1,4 @@
+import { MessageParser } from './message-parser.js';
+
+export declare const typeParser: MessageParser;
+//# sourceMappingURL=message-parser-type.d.ts.map

package/dist/types/mock/schema-mapper/message/message-parser.d.ts

@@ -0,0 +1,12 @@
+import { AppMessagePayload } from '../../messages/message-appmsg';
+import type * as PUPPET from "wechaty-puppet";
+export type MessageParserContext = {
+    puppet: PUPPET.Puppet;
+    isRoomMessage: boolean;
+    appMessagePayload?: AppMessagePayload;
+};
+export type MessageParser = (padPlusMessage: any, ret: PUPPET.payloads.Message, context: MessageParserContext) => Promise<PUPPET.payloads.Message>;
+export declare function addMessageParser(parser: MessageParser): void;
+export declare function executeMessageParsers(puppet: PUPPET.Puppet, padPlusMessage: any, ret: PUPPET.payloads.Message): Promise<PUPPET.payloads.Message>;
+export declare const LOGPRE = "message-parser";
+//# sourceMappingURL=message-parser.d.ts.map

package/dist/types/mock/schema-mapper/message/mod.d.ts

@@ -0,0 +1,4 @@
+import { executeMessageParsers } from './message-parser.js';
+
+export { executeMessageParsers };
+//# sourceMappingURL=mod.d.ts.map

package/dist/types/mock/schema-mapper/message.d.ts

@@ -0,0 +1,3 @@
+import * as PUPPET from "wechaty-puppet";
+export declare function padPlusToWechaty(puppet: PUPPET.Puppet, padPlus: any): Promise<PUPPET.payloads.Message>;
+//# sourceMappingURL=message.d.ts.map

package/dist/types/mock/schema-mapper/room.d.ts

@@ -0,0 +1,5 @@
+import type * as PUPPET from "wechaty-puppet";
+export declare function padPlusRoomToWechaty(contact: any): PUPPET.payloads.Room;
+export declare function padPlusRoomMemberToWechaty(chatRoomMember: any): PUPPET.payloads.RoomMember;
+export declare function chatRoomMemberToContact(chatRoomMember: any): any;
+//# sourceMappingURL=room.d.ts.map