@onebots/adapter-instagram 0.1.0

package/lib/client.js

@@ -0,0 +1,237 @@
+import { EventEmitter } from "node:events";
+import { MetaGraphTransport, MetaWebhookClient } from "@onebots/meta";
+import { emitAllAwaited } from "onebots";
+import { parseAttachmentId, parseBusinessProfile, parseConversation, parseConversationList, parseSendResponse, parseUserProfile, } from "./entities.js";
+import { InstagramError } from "./errors.js";
+import { assertHttpsUrl, assertInstagramConfig, assertMetaId, assertNumericMetaId, } from "./validation.js";
+import { InstagramWebhookCodec } from "./webhook-codec.js";
+/** Graph API 与 Webhook/manual ingress 共用的可嵌入 Instagram Client。 */
+export class InstagramClient extends EventEmitter {
+    config;
+    dependencies;
+    transport;
+    webhook;
+    profile;
+    startTask;
+    startAbort;
+    generation = 0;
+    started = false;
+    constructor(config, dependencies = {}) {
+        super();
+        this.config = config;
+        this.dependencies = dependencies;
+        assertInstagramConfig(config);
+        this.transport = new MetaGraphTransport({
+            accessToken: config.access_token,
+            appSecret: config.app_secret,
+            apiOrigin: config.api_origin || "https://graph.instagram.com",
+            apiVersion: config.api_version,
+        }, dependencies.fetcher);
+        this.webhook = new MetaWebhookClient({
+            receiveMode: config.receive_mode || "webhook",
+            verifyToken: config.verify_token,
+            appSecret: config.app_secret,
+            httpPath: config.http_path,
+            maxBodyBytes: config.max_body_bytes,
+        }, new InstagramWebhookCodec(config.instagram_user_id, config.event_types), { reportError: error => this.reportError(error) });
+        this.webhook.on("event", delivery => this.forward(delivery));
+        this.webhook.on("ready", () => emitAllAwaited(this, "ready"));
+        this.webhook.on("stop", () => emitAllAwaited(this, "stop"));
+    }
+    get receiveMode() {
+        return this.config.receive_mode || "webhook";
+    }
+    get isStarted() {
+        return this.started;
+    }
+    get businessProfile() {
+        return this.profile ? structuredClone(this.profile) : undefined;
+    }
+    async start() {
+        if (this.started)
+            return;
+        if (this.startTask)
+            return this.startTask;
+        const generation = ++this.generation;
+        const controller = new AbortController();
+        this.startAbort = controller;
+        const task = this.startInternal(generation, controller.signal);
+        this.startTask = task;
+        try {
+            await task;
+        }
+        finally {
+            if (this.startTask === task)
+                this.startTask = undefined;
+            if (this.startAbort === controller)
+                this.startAbort = undefined;
+        }
+    }
+    async stop() {
+        ++this.generation;
+        this.startAbort?.abort();
+        await this.startTask?.catch(() => undefined);
+        this.started = false;
+        await this.webhook.stop();
+    }
+    call(method, path, options) {
+        return this.transport.call(method, path, options);
+    }
+    ingest(rawEvent) {
+        return this.webhook.ingest(rawEvent);
+    }
+    ingestHttp(request) {
+        return this.webhook.ingestHttp(request);
+    }
+    acceptHttp(request) {
+        return this.webhook.acceptHttp(request);
+    }
+    async send(recipientId, message, options = {}) {
+        assertNumericMetaId(recipientId, "recipient_id");
+        return parseSendResponse(await this.call("POST", `/${this.config.instagram_user_id}/messages`, {
+            body: {
+                recipient: { id: recipientId },
+                message,
+                ...(options.humanAgent ? { tag: "HUMAN_AGENT" } : {}),
+            },
+        }));
+    }
+    async sendPrivateReply(commentId, text) {
+        assertNumericMetaId(commentId, "comment_id");
+        if (!text)
+            throw InstagramError.invalid("private reply text 不能为空");
+        return parseSendResponse(await this.call("POST", `/${this.config.instagram_user_id}/messages`, {
+            body: { recipient: { comment_id: commentId }, message: { text } },
+        }));
+    }
+    react(recipientId, messageId, action) {
+        assertNumericMetaId(recipientId, "recipient_id");
+        assertMetaId(messageId, "message_id");
+        return this.call("POST", `/${this.config.instagram_user_id}/messages`, {
+            body: {
+                recipient: { id: recipientId },
+                sender_action: action,
+                payload: { message_id: messageId, reaction: "love" },
+            },
+        });
+    }
+    async uploadAttachment(type, source, reusable = true) {
+        let response;
+        if ("url" in source) {
+            response = await this.call("POST", `/${this.config.instagram_user_id}/message_attachments`, {
+                body: {
+                    message: {
+                        attachment: {
+                            type,
+                            payload: {
+                                url: assertHttpsUrl(source.url, "attachment.url"),
+                                is_reusable: reusable,
+                            },
+                        },
+                    },
+                },
+            });
+        }
+        else {
+            const form = new FormData();
+            form.set("message", JSON.stringify({ attachment: { type, payload: { is_reusable: reusable } } }));
+            form.set("filedata", source.blob, source.filename);
+            response = await this.call("POST", `/${this.config.instagram_user_id}/message_attachments`, {
+                form,
+            });
+        }
+        return parseAttachmentId(response);
+    }
+    async getUserProfile(userId) {
+        assertNumericMetaId(userId, "user_id");
+        return parseUserProfile(await this.call("GET", `/${userId}`, {
+            query: {
+                fields: "id,name,username,profile_pic,follower_count,is_user_follow_business,is_business_follow_user,is_verified_user",
+            },
+        }));
+    }
+    async listConversations(after, limit = 25) {
+        return parseConversationList(await this.call("GET", `/${this.config.instagram_user_id}/conversations`, {
+            query: {
+                platform: "instagram",
+                fields: "id,updated_time,participants",
+                limit: boundedLimit(limit),
+                after,
+            },
+        }));
+    }
+    async findConversation(userId) {
+        assertNumericMetaId(userId, "user_id");
+        const result = parseConversationList(await this.call("GET", `/${this.config.instagram_user_id}/conversations`, {
+            query: {
+                platform: "instagram",
+                user_id: userId,
+                fields: "id,updated_time,participants",
+            },
+        }));
+        if (result.data.length > 1) {
+            throw new InstagramError("Conversations API 对单个 IGSID 返回了多个会话", {
+                code: "INSTAGRAM_AMBIGUOUS_CONVERSATION",
+                details: { user_id: userId, count: result.data.length },
+            });
+        }
+        return result.data[0];
+    }
+    async getConversation(conversationId, limit = 20) {
+        assertMetaId(conversationId, "conversation_id");
+        return parseConversation(await this.call("GET", `/${conversationId}`, {
+            query: {
+                fields: `id,updated_time,participants,messages.limit(${boundedMessageLimit(limit)}){id,created_time,from,to,message}`,
+            },
+        }));
+    }
+    async startInternal(generation, signal) {
+        const profile = parseBusinessProfile(await this.call("GET", `/${this.config.instagram_user_id}`, {
+            query: { fields: "id,username" },
+            signal,
+        }));
+        if (profile.id !== this.config.instagram_user_id) {
+            throw new InstagramError("access token 返回了不同的 Instagram User ID", {
+                code: "INSTAGRAM_USER_ID_MISMATCH",
+                details: { expected: this.config.instagram_user_id, actual: profile.id },
+            });
+        }
+        if (this.config.auto_subscribe)
+            await this.subscribe(signal);
+        if (generation !== this.generation)
+            return;
+        this.profile = profile;
+        await this.webhook.start();
+        if (generation !== this.generation) {
+            await this.webhook.stop();
+            return;
+        }
+        this.started = true;
+    }
+    async subscribe(signal) {
+        const fields = this.config.subscribed_fields?.length
+            ? this.config.subscribed_fields
+            : ["messages", "messaging_postbacks", "messaging_seen", "message_reactions"];
+        await this.call("POST", `/${this.config.instagram_user_id}/subscribed_apps`, {
+            query: { subscribed_fields: fields.join(",") },
+            signal,
+        });
+    }
+    forward(delivery) {
+        return emitAllAwaited(this, "event", delivery);
+    }
+    reportError(error) {
+        this.dependencies.reportError?.(error);
+        if (this.listenerCount("error"))
+            this.emit("error", error);
+    }
+}
+function boundedLimit(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw InstagramError.invalid("limit 必须是正安全整数");
+    }
+    return Math.min(value, 100);
+}
+function boundedMessageLimit(value) {
+    return Math.min(boundedLimit(value), 20);
+}

package/lib/entities.d.ts

@@ -0,0 +1,9 @@
+import type { InstagramApiMessage, InstagramBusinessProfile, InstagramConversation, InstagramList, InstagramSendResponse, InstagramUserProfile } from "./types.js";
+export declare function parseBusinessProfile(value: unknown): InstagramBusinessProfile;
+export declare function parseUserProfile(value: unknown): InstagramUserProfile;
+export declare function parseSendResponse(value: unknown): InstagramSendResponse;
+export declare function parseConversationList(value: unknown): InstagramList<InstagramConversation>;
+export declare function parseConversation(value: unknown, field?: string): InstagramConversation;
+export declare function parseApiMessage(value: unknown, field?: string): InstagramApiMessage;
+export declare function parseAttachmentId(value: unknown): string;
+export declare function parseSuccess(value: unknown, field: string): true;

package/lib/entities.js

@@ -0,0 +1,133 @@
+import { InstagramError } from "./errors.js";
+import { assertNumericMetaId, optionalString, requireArray, requireNumber, requireRecord, requireString, } from "./validation.js";
+export function parseBusinessProfile(value) {
+    const root = requireRecord(value, "Instagram business profile");
+    return {
+        id: assertNumericMetaId(root.id, "profile.id"),
+        user_id: optionalNumericId(root.user_id, "profile.user_id"),
+        username: optionalString(root.username, "profile.username"),
+        name: optionalString(root.name, "profile.name"),
+        profile_picture_url: optionalString(root.profile_picture_url, "profile.profile_picture_url"),
+        account_type: optionalString(root.account_type, "profile.account_type"),
+    };
+}
+export function parseUserProfile(value) {
+    const root = requireRecord(value, "Instagram user profile");
+    return {
+        id: assertNumericMetaId(root.id, "user.id"),
+        name: optionalString(root.name, "user.name"),
+        username: optionalString(root.username, "user.username"),
+        profile_pic: optionalString(root.profile_pic, "user.profile_pic"),
+        follower_count: optionalNonNegativeInteger(root.follower_count, "user.follower_count"),
+        is_user_follow_business: optionalBoolean(root.is_user_follow_business, "user.is_user_follow_business"),
+        is_business_follow_user: optionalBoolean(root.is_business_follow_user, "user.is_business_follow_user"),
+        is_verified_user: optionalBoolean(root.is_verified_user, "user.is_verified_user"),
+    };
+}
+export function parseSendResponse(value) {
+    const root = requireRecord(value, "Instagram send response");
+    return {
+        recipient_id: assertNumericMetaId(root.recipient_id, "send.recipient_id"),
+        message_id: requireString(root.message_id, "send.message_id"),
+    };
+}
+export function parseConversationList(value) {
+    const root = requireRecord(value, "Instagram conversations response");
+    return {
+        data: requireArray(root.data, "conversations.data").map((item, index) => parseConversation(item, `conversations.data[${index}]`)),
+        paging: parsePaging(root.paging, "conversations.paging"),
+    };
+}
+export function parseConversation(value, field = "conversation") {
+    const root = requireRecord(value, field);
+    const participants = root.participants;
+    const messages = root.messages;
+    return {
+        id: requireString(root.id, `${field}.id`),
+        updated_time: optionalString(root.updated_time, `${field}.updated_time`),
+        participants: participants === undefined
+            ? undefined
+            : {
+                data: requireArray(requireRecord(participants, `${field}.participants`).data, `${field}.participants.data`).map((item, index) => parsePerson(item, `${field}.participants.data[${index}]`)),
+            },
+        messages: messages === undefined
+            ? undefined
+            : parseMessageConnection(messages, `${field}.messages`),
+    };
+}
+export function parseApiMessage(value, field = "message") {
+    const root = requireRecord(value, field);
+    const from = root.from;
+    const to = root.to;
+    return {
+        id: requireString(root.id, `${field}.id`),
+        created_time: requireString(root.created_time, `${field}.created_time`),
+        from: from === undefined ? undefined : parsePerson(from, `${field}.from`),
+        to: to === undefined
+            ? undefined
+            : {
+                data: requireArray(requireRecord(to, `${field}.to`).data, `${field}.to.data`).map((item, index) => parsePerson(item, `${field}.to.data[${index}]`)),
+            },
+        message: optionalString(root.message, `${field}.message`),
+    };
+}
+export function parseAttachmentId(value) {
+    return requireString(requireRecord(value, "Instagram attachment response").attachment_id, "attachment_id");
+}
+export function parseSuccess(value, field) {
+    const root = requireRecord(value, field);
+    if (root.success !== true) {
+        throw new InstagramError(`${field} 未返回 success`, {
+            code: "INSTAGRAM_INVALID_RESPONSE",
+            details: { response: root },
+        });
+    }
+    return true;
+}
+function parseMessageConnection(value, field) {
+    const root = requireRecord(value, field);
+    return {
+        data: requireArray(root.data, `${field}.data`).map((item, index) => parseApiMessage(item, `${field}.data[${index}]`)),
+        paging: parsePaging(root.paging, `${field}.paging`),
+    };
+}
+function parsePaging(value, field) {
+    if (value === undefined)
+        return undefined;
+    const root = requireRecord(value, field);
+    if (root.cursors === undefined)
+        return {};
+    const cursors = requireRecord(root.cursors, `${field}.cursors`);
+    return {
+        cursors: {
+            before: optionalString(cursors.before, `${field}.cursors.before`),
+            after: optionalString(cursors.after, `${field}.cursors.after`),
+        },
+    };
+}
+function parsePerson(value, field) {
+    const root = requireRecord(value, field);
+    return {
+        id: assertNumericMetaId(root.id, `${field}.id`),
+        username: optionalString(root.username ?? root.name, `${field}.username`),
+    };
+}
+function optionalNumericId(value, field) {
+    return value === undefined ? undefined : assertNumericMetaId(value, field);
+}
+function optionalBoolean(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw InstagramError.invalid(`${field} 必须是 boolean`);
+    return value;
+}
+function optionalNonNegativeInteger(value, field) {
+    if (value === undefined)
+        return undefined;
+    const number = requireNumber(value, field);
+    if (!Number.isSafeInteger(number) || number < 0) {
+        throw InstagramError.invalid(`${field} 必须是非负安全整数`);
+    }
+    return number;
+}

package/lib/errors.d.ts

@@ -0,0 +1,7 @@
+import { MetaError, type MetaErrorOptions } from "@onebots/meta";
+import { ValidationError } from "onebots";
+export declare class InstagramError extends MetaError {
+    constructor(message: string, options: MetaErrorOptions);
+    static invalid(message: string, details?: Record<string, unknown>): ValidationError;
+    static wrap(error: unknown, code?: string): InstagramError;
+}

package/lib/errors.js

@@ -0,0 +1,27 @@
+import { MetaError } from "@onebots/meta";
+import { ValidationError } from "onebots";
+export class InstagramError extends MetaError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "InstagramError";
+    }
+    static invalid(message, details) {
+        return new ValidationError(message, { context: { platform: "instagram", ...details } });
+    }
+    static wrap(error, code = "INSTAGRAM_ERROR") {
+        if (error instanceof InstagramError)
+            return error;
+        if (error instanceof MetaError) {
+            return new InstagramError(error.message, {
+                code: error.code,
+                status: error.status,
+                details: error.details,
+                cause: error,
+            });
+        }
+        return new InstagramError(error instanceof Error ? error.message : String(error), {
+            code,
+            cause: error,
+        });
+    }
+}

package/lib/events.d.ts

@@ -0,0 +1,7 @@
+import { type CommonEvent, type CommonTypes } from "onebots";
+import type { InstagramDelivery } from "./types.js";
+export interface InstagramProjectionContext {
+    botId: CommonTypes.Id;
+    createId(value: string | number): CommonTypes.Id;
+}
+export declare function projectInstagramEvent(delivery: InstagramDelivery, context: InstagramProjectionContext): CommonEvent.Event<unknown>[];

package/lib/events.js

@@ -0,0 +1,122 @@
+import { projectWebhookMessage } from "./messages.js";
+export function projectInstagramEvent(delivery, context) {
+    const event = delivery.event;
+    const item = event.messaging;
+    if (event.event_type === "message" && item?.message) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "message",
+                message_type: "direct",
+                message_id: context.createId(item.message.mid),
+                sender: { id: context.createId(item.sender.id) },
+                message: projectWebhookMessage(item.message),
+                raw_message: item.message.text,
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "message_echo" && item?.message) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: "message_status",
+                sub_type: "echo",
+                message_id: context.createId(item.message.mid),
+                user: { id: context.createId(item.recipient.id) },
+                message: projectWebhookMessage(item.message),
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "message_deleted" && item?.message) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: "message_deleted",
+                message_id: context.createId(item.message.mid),
+                user: { id: context.createId(item.sender.id) },
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "message_edit" && item?.message_edit) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: "message_updated",
+                message_id: context.createId(String(item.message_edit.mid)),
+                user: { id: context.createId(item.sender.id) },
+                message: [{ type: "text", data: { text: String(item.message_edit.text) } }],
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "read" && item?.read) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: "message_status",
+                sub_type: "read",
+                message_id: context.createId(String(item.read.mid)),
+                user: { id: context.createId(item.sender.id) },
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "reaction" && item?.reaction) {
+        const removed = item.reaction.action === "unreact";
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: removed ? "reaction_removed" : "reaction_added",
+                message_id: context.createId(String(item.reaction.mid)),
+                user: { id: context.createId(item.sender.id) },
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    if (event.event_type === "postback" && item?.postback) {
+        return [
+            {
+                ...base(delivery, context),
+                type: "notice",
+                notice_type: "interaction",
+                sub_type: "postback",
+                message_id: context.createId(String(item.postback.mid)),
+                user: { id: context.createId(item.sender.id) },
+                extensions: messagingExtensions(event.source, item),
+            },
+        ];
+    }
+    return [
+        {
+            ...base(delivery, context),
+            type: "notice",
+            notice_type: "custom",
+            sub_type: event.source === "standby" ? `standby_${event.event_type}` : event.event_type,
+            user: item ? { id: context.createId(item.sender.id) } : undefined,
+            extensions: item
+                ? messagingExtensions(event.source, item)
+                : { instagram: { change: event.change } },
+        },
+    ];
+}
+function base(delivery, context) {
+    return {
+        id: context.createId(`event:${delivery.id}`),
+        timestamp: delivery.event.messaging?.timestamp || delivery.event.entry_time,
+        type: "custom",
+        platform: "instagram",
+        bot_id: context.botId,
+        raw_event: delivery.rawEnvelope.raw,
+    };
+}
+function messagingExtensions(source, item) {
+    return { instagram: { source, messaging: item.raw } };
+}

package/lib/http-host.d.ts

@@ -0,0 +1,14 @@
+import type { BaseApp } from "onebots";
+import type { InstagramClient } from "./client.js";
+/** 路径只注册一次，热重载时动态解析当前 Client，并传递签名覆盖的精确原始体。 */
+export declare class InstagramHttpHost {
+    private readonly app;
+    private readonly resolveClient;
+    private readonly owners;
+    private readonly accountPaths;
+    private readonly mounted;
+    constructor(app: BaseApp, resolveClient: (accountId: string) => InstagramClient | undefined);
+    mount(accountId: string, client: InstagramClient): void;
+    private accept;
+    private isActive;
+}

package/lib/http-host.js

@@ -0,0 +1,64 @@
+import { InstagramError } from "./errors.js";
+/** 路径只注册一次，热重载时动态解析当前 Client，并传递签名覆盖的精确原始体。 */
+export class InstagramHttpHost {
+    app;
+    resolveClient;
+    owners = new Map();
+    accountPaths = new Map();
+    mounted = new Set();
+    constructor(app, resolveClient) {
+        this.app = app;
+        this.resolveClient = resolveClient;
+    }
+    mount(accountId, client) {
+        if (client.receiveMode === "manual")
+            return;
+        const path = normalizePath(client.config.http_path || "");
+        if (!path)
+            throw InstagramError.invalid("webhook 模式必须配置 http_path");
+        const current = this.owners.get(path);
+        if (current && current !== accountId && this.isActive(path, current)) {
+            throw new InstagramError(`Instagram HTTP 路径 ${path} 已由账号 ${current} 使用`, {
+                code: "INSTAGRAM_HTTP_PATH_CONFLICT",
+            });
+        }
+        this.owners.set(path, accountId);
+        this.accountPaths.set(accountId, path);
+        if (this.mounted.has(path))
+            return;
+        this.mounted.add(path);
+        this.app.router.get(path, ctx => this.accept(path, ctx));
+        this.app.router.post(path, ctx => this.accept(path, ctx));
+    }
+    async accept(path, ctx) {
+        const owner = this.owners.get(path);
+        const client = owner ? this.resolveClient(owner) : undefined;
+        if (!owner || !client || !this.isActive(path, owner)) {
+            ctx.status = 404;
+            ctx.body = { error: { code: "NOT_FOUND", message: "Instagram 路由未激活" } };
+            return;
+        }
+        const raw = ctx.request.rawBody;
+        const response = await client.ingestHttp({
+            method: ctx.method,
+            url: ctx.url,
+            headers: { "x-hub-signature-256": ctx.get("x-hub-signature-256") || undefined },
+            rawBody: typeof raw === "string"
+                ? new TextEncoder().encode(raw)
+                : raw instanceof Uint8Array
+                    ? new Uint8Array(raw)
+                    : undefined,
+        });
+        ctx.status = response.status;
+        ctx.body = response.body;
+        for (const [name, value] of Object.entries(response.headers))
+            ctx.set(name, value);
+    }
+    isActive(path, accountId) {
+        const client = this.resolveClient(accountId);
+        return Boolean(client && client.receiveMode !== "manual" && this.accountPaths.get(accountId) === path);
+    }
+}
+function normalizePath(value) {
+    return value === "/" ? "/" : value.replace(/\/+$/u, "");
+}

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import { type Schema } from "onebots";
+import { InstagramAdapter } from "./adapter.js";
+import type { InstagramConfig } from "./types.js";
+export { InstagramAdapter };
+export { InstagramClient, type InstagramClientDependencies } from "./client.js";
+export { describeInstagramCapabilities, INSTAGRAM_EVENT_TYPES, INSTAGRAM_WEBHOOK_FIELDS, instagramCapabilities, } from "./capabilities.js";
+export { InstagramError } from "./errors.js";
+export { projectInstagramEvent } from "./events.js";
+export { compileInstagramMessage, projectApiMessage, projectWebhookMessage, type InstagramAttachmentUploader, } from "./messages.js";
+export { executeInstagramPlatformAction, INSTAGRAM_PLATFORM_ACTIONS, type InstagramPlatformAction, } from "./platform-actions.js";
+export { InstagramWebhookCodec } from "./webhook-codec.js";
+export type { InstagramApiMessage, InstagramAttachment, InstagramBusinessProfile, InstagramCallOptions, InstagramClientEvents, InstagramConfig, InstagramConversation, InstagramDelivery, InstagramEvent, InstagramEventType, InstagramGraphMethod, InstagramHttpRequest, InstagramHttpResponse, InstagramIngestResult, InstagramMessage, InstagramMessagingItem, InstagramOutgoingMessage, InstagramReceiveMode, InstagramSendResponse, InstagramUserProfile, InstagramWebhookEnvelope, } from "./types.js";
+export declare const instagramSchema: Schema;
+declare module "onebots" {
+    namespace Adapter {
+        interface Configs {
+            instagram: InstagramConfig;
+        }
+    }
+}