@zhin.js/adapter-weixin-ilink 1.0.1 → 1.1.2

package/adapters/weixin-ilink/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Convention entry: discover `adapters/weixin-ilink/index.ts` → defineAdapter.
+ */
+import { defineAdapter } from 'zhin.js/adapter';
+import { WeixinIlinkEndpoint } from '../../src/endpoint.js';
+import {
+  resolveWeixinIlinkConfig,
+  type WeixinIlinkEndpointConfig,
+} from '../../src/protocol.js';
+import { weixinIlinkRuntimeStateToken } from '../../src/weixin-ilink-runtime-state.js';
+
+export { WeixinIlinkEndpoint } from '../../src/endpoint.js';
+export type {
+  WeixinIlinkEndpointOptions,
+  WeixinIlinkGetUpdates,
+  WeixinIlinkNotifyStart,
+  WeixinIlinkNotifyStop,
+  WeixinIlinkSendText,
+} from '../../src/endpoint.js';
+
+export default defineAdapter<WeixinIlinkEndpointConfig>({
+  capabilities: ['inbound', 'outbound'],
+  operations: ['typing'],
+  // 所有媒体（url 下载 / base64 落盘 / 本地 path）统一物化后走 CDN 上传（sendWeixinMediaFile），
+  // 无直发面；微信无卡片交互面，交互段降级纯文本。
+  segments: {
+    outboundMedia: ['upload'],
+    interactive: 'text',
+  },
+  create(context) {
+    const config = resolveWeixinIlinkConfig(context.config);
+    // 注册到插件运行时状态（weixin-ilink endpoint list 的"运行中"数据源）
+    context.use(weixinIlinkRuntimeStateToken).endpoints.set(config.id, {
+      id: config.id,
+      // iLink 仅长轮询一种接入方式，无 config.connection 字段
+      mode: 'long-poll',
+    });
+    return new WeixinIlinkEndpoint({
+      id: context.id,
+      config,
+    });
+  },
+});

package/commands/weixin-ilink/endpoint/add/[id]/index.js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { weixinIlinkEndpointCommands } from '../../definition.js';
+export default weixinIlinkEndpointCommands.add;

package/commands/weixin-ilink/endpoint/add/[id]/index.ts

@@ -0,0 +1,3 @@
+import { weixinIlinkEndpointCommands } from '../../definition.js';
+
+export default weixinIlinkEndpointCommands.add;

package/commands/weixin-ilink/endpoint/definition.js

@@ -0,0 +1,17 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+/**
+ * `weixin-ilink endpoint` 命令族：由 @zhin.js/adapter 的 createEndpointCommands 套件生成。
+ * commands/weixin-ilink/endpoint/ 下的 list / add / remove 直接默认导出这三项。
+ */
+import { createEndpointCommands } from 'zhin.js/adapter';
+import { defineCommand } from 'zhin.js/command';
+import { weixinIlinkRuntimeStateToken } from "../../../lib/weixin-ilink-runtime-state.js";
+export const weixinIlinkEndpointCommands = createEndpointCommands({
+    adapterKey: 'weixin-ilink',
+    adapterDisplayName: 'Weixin iLink',
+    fields: [
+        { key: 'botToken', required: true, env: true, description: 'iLink bot token' },
+    ],
+    running: (use) => use(weixinIlinkRuntimeStateToken).endpoints.values(),
+    describeEntry: (entry) => `botToken: ${String(entry.botToken)}`,
+}, defineCommand);

package/commands/weixin-ilink/endpoint/definition.ts

@@ -0,0 +1,17 @@
+/**
+ * `weixin-ilink endpoint` 命令族：由 @zhin.js/adapter 的 createEndpointCommands 套件生成。
+ * commands/weixin-ilink/endpoint/ 下的 list / add / remove 直接默认导出这三项。
+ */
+import { createEndpointCommands } from 'zhin.js/adapter';
+import { defineCommand } from 'zhin.js/command';
+import { weixinIlinkRuntimeStateToken } from '../../../src/weixin-ilink-runtime-state.js';
+
+export const weixinIlinkEndpointCommands = createEndpointCommands({
+  adapterKey: 'weixin-ilink',
+  adapterDisplayName: 'Weixin iLink',
+  fields: [
+    { key: 'botToken', required: true, env: true, description: 'iLink bot token' },
+  ],
+  running: (use) => use(weixinIlinkRuntimeStateToken).endpoints.values(),
+  describeEntry: (entry) => `botToken: ${String(entry.botToken)}`,
+}, defineCommand);

package/commands/weixin-ilink/endpoint/list/index.js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { weixinIlinkEndpointCommands } from '../definition.js';
+export default weixinIlinkEndpointCommands.list;

package/commands/weixin-ilink/endpoint/list/index.ts

@@ -0,0 +1,3 @@
+import { weixinIlinkEndpointCommands } from '../definition.js';
+
+export default weixinIlinkEndpointCommands.list;

package/commands/weixin-ilink/endpoint/remove/[id]/index.js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { weixinIlinkEndpointCommands } from '../../definition.js';
+export default weixinIlinkEndpointCommands.remove;

package/commands/weixin-ilink/endpoint/remove/[id]/index.ts

@@ -0,0 +1,3 @@
+import { weixinIlinkEndpointCommands } from '../../definition.js';
+
+export default weixinIlinkEndpointCommands.remove;

package/lib/aes-ecb.d.ts

@@ -4,4 +4,3 @@ export declare function encryptAesEcb(plaintext: Buffer, key: Buffer): Buffer;
 export declare function decryptAesEcb(ciphertext: Buffer, key: Buffer): Buffer;
 /** Compute AES-128-ECB ciphertext size (PKCS7 padding to 16-byte boundary). */
 export declare function aesEcbPaddedSize(plaintextSize: number): number;
-//# sourceMappingURL=aes-ecb.d.ts.map

package/lib/aes-ecb.js

@@ -16,4 +16,3 @@ export function decryptAesEcb(ciphertext, key) {
 export function aesEcbPaddedSize(plaintextSize) {
     return Math.ceil((plaintextSize + 1) / 16) * 16;
 }
-//# sourceMappingURL=aes-ecb.js.map

package/lib/cdn-upload.d.ts

@@ -15,4 +15,3 @@ export declare function uploadBufferToCdn(params: {
 }): Promise<{
     downloadParam: string;
 }>;
-//# sourceMappingURL=cdn-upload.d.ts.map

package/lib/cdn-upload.js

@@ -70,4 +70,3 @@ export async function uploadBufferToCdn(params) {
     }
     return { downloadParam };
 }
-//# sourceMappingURL=cdn-upload.js.map

package/lib/cdn-url.d.ts

@@ -11,4 +11,3 @@ export declare function buildCdnUploadUrl(params: {
     uploadParam: string;
     filekey: string;
 }): string;
-//# sourceMappingURL=cdn-url.d.ts.map

package/lib/cdn-url.js

@@ -11,4 +11,3 @@ export function buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl) {
 export function buildCdnUploadUrl(params) {
     return `${params.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(params.uploadParam)}&filekey=${encodeURIComponent(params.filekey)}`;
 }
-//# sourceMappingURL=cdn-url.js.map

package/lib/client.d.ts

@@ -0,0 +1,35 @@
+import type { WeixinContextTokenStore } from './context-store.js';
+import type { WeixinIlinkCredentials } from './credentials.js';
+import type { WeixinConfigManager } from './ilink-config-cache.js';
+import type { IlinkClientMetadata } from './ilink-meta.js';
+import type { ResolvedWeixinIlinkConfig } from './protocol.js';
+import { sendMessageWeixin } from './weixin-send.js';
+/** Direct iLink API client backed by the Endpoint's live authenticated session. */
+export declare class WeixinIlinkClient {
+    #private;
+    readonly config: ResolvedWeixinIlinkConfig;
+    constructor(config: ResolvedWeixinIlinkConfig, metadata: IlinkClientMetadata, resolveCredentials: () => WeixinIlinkCredentials | null, resolveConfigManager: () => WeixinConfigManager | undefined, sendTextImpl: typeof sendMessageWeixin, contextTokens: WeixinContextTokenStore);
+    get credentials(): WeixinIlinkCredentials;
+    get authenticated(): boolean;
+    get apiBaseUrl(): string;
+    get cdnBaseUrl(): string;
+    contextToken(userId: string): string | undefined;
+    reachableUserIds(): string[];
+    sendText(to: string, text: string): Promise<{
+        messageId: string;
+    }>;
+    sendMedia(to: string, filePath: string, text?: string): Promise<{
+        messageId: string;
+    }>;
+    sendTyping(userId: string, status: number): Promise<boolean>;
+}
+export type WeixinIlinkClientEventMap = Record<string, unknown>;
+declare module '@zhin.js/feature-kit' {
+    interface AdapterClientRegistry {
+        readonly 'weixin-ilink': {
+            readonly client: WeixinIlinkClient;
+            readonly events: WeixinIlinkClientEventMap;
+        };
+    }
+}
+export declare const weixinIlinkClient: import("@zhin.js/adapter").EndpointClientToken<WeixinIlinkClient, WeixinIlinkClientEventMap>;

package/lib/client.js

@@ -0,0 +1,89 @@
+import { sendTyping } from './ilink-api.js';
+import { sendWeixinMediaFile } from './weixin-send-media.js';
+import { defineEndpointClient } from 'zhin.js/adapter';
+/** Direct iLink API client backed by the Endpoint's live authenticated session. */
+export class WeixinIlinkClient {
+    config;
+    #metadata;
+    #resolveCredentials;
+    #resolveConfigManager;
+    #sendTextImpl;
+    #contextTokens;
+    constructor(config, metadata, resolveCredentials, resolveConfigManager, sendTextImpl, contextTokens) {
+        this.config = config;
+        this.#metadata = metadata;
+        this.#resolveCredentials = resolveCredentials;
+        this.#resolveConfigManager = resolveConfigManager;
+        this.#sendTextImpl = sendTextImpl;
+        this.#contextTokens = contextTokens;
+    }
+    get credentials() {
+        const credentials = this.#resolveCredentials();
+        if (!credentials?.botToken)
+            throw new Error('weixin-ilink client not authenticated');
+        return credentials;
+    }
+    get authenticated() {
+        return Boolean(this.#resolveCredentials()?.botToken);
+    }
+    get apiBaseUrl() {
+        return this.#resolveCredentials()?.baseUrl ?? this.config.baseUrl;
+    }
+    get cdnBaseUrl() {
+        return this.config.cdnBaseUrl;
+    }
+    contextToken(userId) {
+        return this.#contextTokens.get(userId);
+    }
+    reachableUserIds() {
+        return this.#contextTokens.userIds();
+    }
+    async sendText(to, text) {
+        const contextToken = this.contextToken(to);
+        if (!contextToken)
+            throw new Error(`missing context_token for peer ${to}`);
+        return this.#sendTextImpl({
+            to,
+            text,
+            opts: {
+                baseUrl: this.apiBaseUrl,
+                metadata: this.#metadata,
+                token: this.credentials.botToken,
+                contextToken,
+            },
+        });
+    }
+    async sendMedia(to, filePath, text = '') {
+        const contextToken = this.contextToken(to);
+        if (!contextToken)
+            throw new Error(`missing context_token for peer ${to}`);
+        return sendWeixinMediaFile({
+            filePath,
+            to,
+            text,
+            opts: {
+                baseUrl: this.apiBaseUrl,
+                metadata: this.#metadata,
+                token: this.credentials.botToken,
+                contextToken,
+            },
+            cdnBaseUrl: this.cdnBaseUrl,
+        });
+    }
+    async sendTyping(userId, status) {
+        const manager = this.#resolveConfigManager();
+        if (!this.authenticated || !manager)
+            return false;
+        const cfg = await manager.getForUser(userId, this.contextToken(userId));
+        if (!cfg.typingTicket)
+            return false;
+        await sendTyping({
+            baseUrl: this.apiBaseUrl,
+            metadata: this.#metadata,
+            token: this.credentials.botToken,
+            body: { ilink_user_id: userId, typing_ticket: cfg.typingTicket, status },
+        });
+        return true;
+    }
+}
+export const weixinIlinkClient = defineEndpointClient('weixin-ilink');

package/lib/context-store.d.ts

@@ -1,2 +1,15 @@
-export { setContextToken, getContextToken, restoreContextTokens, clearContextTokensForAccount, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";
-//# sourceMappingURL=context-store.d.ts.map
+import type { WeixinIlinkStateStore } from './credentials.js';
+/** Endpoint-owned context-token repository with account-scoped persistence. */
+export declare class WeixinContextTokenStore {
+    #private;
+    readonly state: WeixinIlinkStateStore;
+    constructor(state: WeixinIlinkStateStore);
+    get accountId(): string;
+    get(userId: string): string | undefined;
+    set(userId: string, token: string): void;
+    userIds(): string[];
+    restore(): void;
+    flush(): void;
+    clear(): void;
+}
+export { bodyFromItemList, isMediaItem } from './weixin-inbound.js';

package/lib/context-store.js

@@ -1,2 +1,93 @@
-export { setContextToken, getContextToken, restoreContextTokens, clearContextTokensForAccount, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";
-//# sourceMappingURL=context-store.js.map
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './ilink-logger.js';
+const PERSIST_DEBOUNCE_MS = 500;
+/** Endpoint-owned context-token repository with account-scoped persistence. */
+export class WeixinContextTokenStore {
+    state;
+    #tokens = new Map();
+    #persistTimer;
+    constructor(state) {
+        this.state = state;
+    }
+    get accountId() {
+        return this.state.endpointId;
+    }
+    get(userId) {
+        const value = this.#tokens.get(userId);
+        logger.debug(`contextTokenStore.get: account=${this.accountId} user=${userId} found=${value !== undefined} storeSize=${this.#tokens.size}`);
+        return value;
+    }
+    set(userId, token) {
+        logger.debug(`contextTokenStore.set: account=${this.accountId} user=${userId}`);
+        this.#tokens.set(userId, token);
+        this.#schedulePersist();
+    }
+    userIds() {
+        return [...this.#tokens.keys()];
+    }
+    restore() {
+        const filePath = this.#filePath();
+        try {
+            if (!fs.existsSync(filePath))
+                return;
+            const tokens = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            let count = 0;
+            for (const [userId, token] of Object.entries(tokens)) {
+                if (typeof token !== 'string' || !token)
+                    continue;
+                this.#tokens.set(userId, token);
+                count += 1;
+            }
+            logger.info(`contextTokenStore.restore: restored ${count} tokens for account=${this.accountId}`);
+        }
+        catch (error) {
+            logger.warn(`contextTokenStore.restore: failed to read ${filePath}: ${String(error)}`);
+        }
+    }
+    flush() {
+        if (this.#persistTimer) {
+            clearTimeout(this.#persistTimer);
+            this.#persistTimer = undefined;
+        }
+        this.#persist();
+    }
+    clear() {
+        if (this.#persistTimer) {
+            clearTimeout(this.#persistTimer);
+            this.#persistTimer = undefined;
+        }
+        this.#tokens.clear();
+        const filePath = this.#filePath();
+        try {
+            if (fs.existsSync(filePath))
+                fs.unlinkSync(filePath);
+        }
+        catch (error) {
+            logger.warn(`contextTokenStore.clear: failed to remove ${filePath}: ${String(error)}`);
+        }
+    }
+    #filePath() {
+        return this.state.contextTokensPath();
+    }
+    #schedulePersist() {
+        if (this.#persistTimer)
+            clearTimeout(this.#persistTimer);
+        this.#persistTimer = setTimeout(() => {
+            this.#persistTimer = undefined;
+            this.#persist();
+        }, PERSIST_DEBOUNCE_MS);
+        this.#persistTimer.unref?.();
+    }
+    #persist() {
+        const filePath = this.#filePath();
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, JSON.stringify(Object.fromEntries(this.#tokens)), 'utf-8');
+        }
+        catch (error) {
+            logger.warn(`contextTokenStore.persist: failed to write ${filePath}: ${String(error)}`);
+        }
+    }
+}
+export { bodyFromItemList, isMediaItem } from './weixin-inbound.js';

package/lib/credentials.d.ts

@@ -5,11 +5,18 @@ export interface WeixinIlinkCredentials {
     baseUrl?: string;
     updatedAt?: string;
 }
-export declare function resolveStateDir(): string;
-export declare function credentialsPath(endpointName: string): string;
-export declare function loadCredentials(endpointName: string): WeixinIlinkCredentials | null;
-export declare function saveCredentials(endpointName: string, creds: WeixinIlinkCredentials): void;
-export declare function syncBufPath(endpointName: string): string;
-export declare function loadSyncBuf(endpointName: string): string;
-export declare function saveSyncBuf(endpointName: string, buf: string): void;
-//# sourceMappingURL=credentials.d.ts.map
+/** Endpoint-owned persistence for credentials, cursors, context tokens, and media. */
+export declare class WeixinIlinkStateStore {
+    readonly endpointId: string;
+    readonly rootDir: string;
+    constructor(endpointId: string, rootDir: string);
+    endpointDirectory(): string;
+    credentialsPath(): string;
+    loadCredentials(): WeixinIlinkCredentials | null;
+    saveCredentials(credentials: WeixinIlinkCredentials): void;
+    syncBufPath(): string;
+    loadSyncBuf(): string;
+    saveSyncBuf(value: string): void;
+    contextTokensPath(): string;
+    mediaDirectory(subdir: string): string;
+}

package/lib/credentials.js

@@ -1,49 +1,65 @@
-import fs from "node:fs";
-import path from "node:path";
-const DEFAULT_DATA_DIR = "./data/weixin-ilink";
-export function resolveStateDir() {
-    return process.env.ZHIN_DATA_DIR
-        ? path.join(process.env.ZHIN_DATA_DIR, "weixin-ilink")
-        : DEFAULT_DATA_DIR;
-}
-export function credentialsPath(endpointName) {
-    return path.join(resolveStateDir(), `${endpointName}.json`);
-}
-export function loadCredentials(endpointName) {
-    const file = credentialsPath(endpointName);
-    try {
-        if (!fs.existsSync(file))
-            return null;
-        const raw = fs.readFileSync(file, "utf-8");
-        const data = JSON.parse(raw);
-        if (!data.botToken?.trim())
+import fs from 'node:fs';
+import path from 'node:path';
+/** Endpoint-owned persistence for credentials, cursors, context tokens, and media. */
+export class WeixinIlinkStateStore {
+    endpointId;
+    rootDir;
+    constructor(endpointId, rootDir) {
+        if (!/^[A-Za-z0-9_.-]+$/u.test(endpointId)) {
+            throw new TypeError('Weixin iLink state endpoint id is invalid');
+        }
+        if (!rootDir.trim())
+            throw new TypeError('Weixin iLink state root is required');
+        this.endpointId = endpointId;
+        this.rootDir = rootDir;
+    }
+    endpointDirectory() {
+        return path.join(this.rootDir, this.endpointId);
+    }
+    credentialsPath() {
+        return path.join(this.endpointDirectory(), 'credentials.json');
+    }
+    loadCredentials() {
+        const file = this.credentialsPath();
+        try {
+            if (!fs.existsSync(file))
+                return null;
+            const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            return data.botToken?.trim() ? data : null;
+        }
+        catch {
             return null;
-        return data;
+        }
     }
-    catch {
-        return null;
+    saveCredentials(credentials) {
+        const file = this.credentialsPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ ...credentials, updatedAt: new Date().toISOString() }, null, 2), 'utf-8');
     }
-}
-export function saveCredentials(endpointName, creds) {
-    const file = credentialsPath(endpointName);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, JSON.stringify({ ...creds, updatedAt: new Date().toISOString() }, null, 2), "utf-8");
-}
-export function syncBufPath(endpointName) {
-    return path.join(resolveStateDir(), `${endpointName}.sync-buf`);
-}
-export function loadSyncBuf(endpointName) {
-    const file = syncBufPath(endpointName);
-    try {
-        return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "";
+    syncBufPath() {
+        return path.join(this.endpointDirectory(), 'sync-buf');
     }
-    catch {
-        return "";
+    loadSyncBuf() {
+        const file = this.syncBufPath();
+        try {
+            return fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    saveSyncBuf(value) {
+        const file = this.syncBufPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, value, 'utf-8');
+    }
+    contextTokensPath() {
+        return path.join(this.endpointDirectory(), 'context-tokens.json');
+    }
+    mediaDirectory(subdir) {
+        if (subdir !== 'inbound' && subdir !== 'outbound') {
+            throw new TypeError(`Unsupported Weixin iLink media directory: ${subdir}`);
+        }
+        return path.join(this.endpointDirectory(), 'media', subdir);
     }
 }
-export function saveSyncBuf(endpointName, buf) {
-    const file = syncBufPath(endpointName);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, buf, "utf-8");
-}
-//# sourceMappingURL=credentials.js.map

package/lib/endpoint.d.ts

@@ -1,37 +1,42 @@
-import { Endpoint, Message, type SendOptions } from "zhin.js";
-import type { WeixinMessage } from "./ilink-types.js";
-import type { WeixinInboundMediaOpts } from "./weixin-inbound.js";
-import type { WeixinIlinkEndpointConfig } from "./types.js";
-import type { WeixinIlinkAdapter } from "./adapter.js";
-import { WeixinIlinkTypingIndicatorManager } from "./typing-indicator.js";
-export type WeixinMessageWithMedia = WeixinMessage & {
-    _media?: WeixinInboundMediaOpts;
-};
-export declare class WeixinIlinkEndpoint implements Endpoint<WeixinIlinkEndpointConfig, WeixinMessage> {
-    adapter: WeixinIlinkAdapter;
-    $config: WeixinIlinkEndpointConfig;
-    $connected: boolean;
-    $typingIndicator?: WeixinIlinkTypingIndicatorManager;
-    private creds;
-    private pollAbort?;
-    private pollPromise?;
-    private configManager?;
-    get $id(): string;
+import { Endpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest } from 'zhin.js/adapter';
+import type { CapabilityId } from 'zhin.js';
+import { getUpdates, notifyStart, notifyStop } from './ilink-api.js';
+import { IlinkClientMetadata } from './ilink-meta.js';
+import { type WeixinIlinkCredentials, WeixinIlinkStateStore } from './credentials.js';
+import { WeixinContextTokenStore } from './context-store.js';
+import { IlinkSessionGuard } from './ilink-session-guard.js';
+import { sendMessageWeixin } from './weixin-send.js';
+import { type ResolvedWeixinIlinkConfig, type WeixinMessageWithMedia } from './protocol.js';
+import { WeixinIlinkClient } from './client.js';
+export type WeixinIlinkSendText = typeof sendMessageWeixin;
+export type WeixinIlinkNotifyStart = typeof notifyStart;
+export type WeixinIlinkNotifyStop = typeof notifyStop;
+export type WeixinIlinkGetUpdates = typeof getUpdates;
+export interface WeixinIlinkEndpointOptions {
+    readonly id: CapabilityId;
+    readonly config: ResolvedWeixinIlinkConfig;
+    readonly resolveCredentials?: (config: ResolvedWeixinIlinkConfig, metadata: IlinkClientMetadata, state: WeixinIlinkStateStore, signal?: AbortSignal) => Promise<WeixinIlinkCredentials>;
+    /** Test / internal: override network side effects. */
+    readonly notifyStart?: WeixinIlinkNotifyStart;
+    readonly notifyStop?: WeixinIlinkNotifyStop;
+    readonly getUpdates?: WeixinIlinkGetUpdates;
+    readonly sendText?: WeixinIlinkSendText;
+    readonly state?: WeixinIlinkStateStore;
+    readonly contextTokens?: WeixinContextTokenStore;
+    readonly sessionGuard?: IlinkSessionGuard;
+}
+export declare class WeixinIlinkEndpoint extends Endpoint<WeixinIlinkClient> {
+    #private;
+    readonly client: WeixinIlinkClient;
+    readonly management: EndpointManagement;
+    readonly control: EndpointControl;
+    constructor(options: WeixinIlinkEndpointOptions);
     get hasCredentials(): boolean;
-    get pluginLogger(): import("zhin.js").Logger;
-    constructor(adapter: WeixinIlinkAdapter, $config: WeixinIlinkEndpointConfig);
-    apiBaseUrl(): string;
-    cdnBaseUrl(): string;
-    $connect(): Promise<void>;
-    $disconnect(): Promise<void>;
-    sendTypingToUser(userId: string, status: number): Promise<void>;
-    $recallMessage(_id: string): Promise<void>;
-    $formatMessage(msg: WeixinMessageWithMedia): Message<WeixinMessage>;
-    private buildInboundContent;
-    $sendMessage(options: SendOptions): Promise<string>;
-    private pollLoop;
-    private handleInboundMessage;
-    private downloadInboundMedia;
-    private saveInboundMedia;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    /** Test / internal: admit a parsed message when the endpoint is open. */
+    admit(msg: WeixinMessageWithMedia): void;
 }
-//# sourceMappingURL=endpoint.d.ts.map