import { Bot } from "grammy";
import type { PlatformAdapter, SurfaceCapabilities, IngressSink, InteractionEvent, RunRenderer, ReplyTarget as BotReplyTarget, ConversationStore, MessageRef, ProviderActor, UserQuery, CommandSpec } from "@copilotkit/channels-core";
import type { ChannelNode, ThreadMessage, EmojiValue, EphemeralResult } from "@copilotkit/channels-ui";
import type { TelegramAdapterOptions, TelegramPayload } from "./types.js";
/**
 * Update types that the Telegram adapter subscribes to. Includes
 * `message_reaction` so the bot receives emoji-reaction events.
 *
 * In **group** chats the bot must be an administrator to receive
 * `message_reaction` updates; private chats and channels work without
 * additional permissions.
 *
 * For **webhook** deployments pass this list to `setWebhook`:
 * ```ts
 * await bot.api.setWebhook(url, { allowed_updates: [...TELEGRAM_ALLOWED_UPDATES] });
 * ```
 * Long-polling (`start()`) passes it automatically.
 */
export declare const TELEGRAM_ALLOWED_UPDATES: readonly ["message", "edited_message", "callback_query", "message_reaction"];
/**
 * Telegram `PlatformAdapter`: ingress via grammY (long-polling or webhook),
 * egress via the package's HTML renderer + chunked-edit streaming.
 *
 * Construction is side-effect-free — the grammY {@link Bot} is created but no
 * network call is made until {@link start} (which owns `getMe` + ingress).
 */
export declare class TelegramAdapter implements PlatformAdapter {
    private readonly opts;
    readonly platform = "telegram";
    readonly capabilities: SurfaceCapabilities;
    readonly ackDeadlineMs = 3000;
    /** Public/assignable so tests can inject a fake (`adapter.bot = fake`). */
    bot: Bot;
    botUsername: string;
    botUserId: number;
    private readonly store;
    /** In webhook mode, the Node HTTP server standing up the webhook endpoint. */
    private webhookServer?;
    constructor(opts: TelegramAdapterOptions);
    /** Greeting text to post on conversation start (wired by the example's onThreadStarted). */
    get greeting(): string | undefined;
    /** Suggested prompt chips to surface on conversation start. */
    get suggestedPrompts(): {
        title: string;
        message: string;
    }[] | undefined;
    start(sink: IngressSink): Promise<void>;
    /** Resolve the effective ingress mode, expanding "auto" by environment. */
    private resolveMode;
    /**
     * Register the webhook with Telegram and stand up a minimal Node HTTP server
     * that feeds updates to grammY via {@link webhookCallback}. Requires
     * `opts.webhook.domain`.
     */
    private startWebhook;
    stop(): Promise<void>;
    render(ir: ChannelNode[]): TelegramPayload;
    post(target: BotReplyTarget, ir: ChannelNode[]): Promise<MessageRef>;
    update(ref: MessageRef, ir: ChannelNode[]): Promise<void>;
    stream(target: BotReplyTarget, chunks: AsyncIterable<string>): Promise<MessageRef>;
    delete(ref: MessageRef): Promise<void>;
    createRunRenderer(target: BotReplyTarget): RunRenderer;
    decodeInteraction(raw: unknown): InteractionEvent | undefined;
    lookupUser(q: UserQuery): Promise<ProviderActor | undefined>;
    get conversationStore(): ConversationStore;
    getMessages(target: BotReplyTarget): Promise<ThreadMessage[]>;
    postFile(target: BotReplyTarget, { bytes, filename, }: {
        bytes: Uint8Array;
        filename: string;
        title?: string;
        altText?: string;
    }): Promise<{
        ok: boolean;
        fileId?: string;
        error?: string;
    }>;
    registerCommands(specs: readonly CommandSpec[]): Promise<void>;
    setThreadTitle(target: BotReplyTarget, title: string): Promise<{
        ok: boolean;
        error?: string;
    }>;
    addReaction(target: BotReplyTarget, messageRef: MessageRef, emoji: EmojiValue): Promise<{
        ok: boolean;
        error?: string;
    }>;
    removeReaction(target: BotReplyTarget, messageRef: MessageRef, _emoji: EmojiValue): Promise<{
        ok: boolean;
        error?: string;
    }>;
    postEphemeral(_target: BotReplyTarget, user: ProviderActor | string, ir: ChannelNode[], opts: {
        fallbackToDM: boolean;
    }): Promise<EphemeralResult | null>;
    setSuggestedPrompts(_target: BotReplyTarget, _prompts: ReadonlyArray<{
        title: string;
        message: string;
    }>, _opts?: {
        title?: string;
    }): Promise<{
        ok: boolean;
        error?: string;
    }>;
    /**
     * Return the store's conversation key for a {@link ReplyTarget}.
     *
     * Prefers the `conversationKey` field stamped at ingress (by the listener or
     * `decodeInteraction`), which carries the exact key used for the live
     * conversation — including the `user:<id>` scope that non-forum group chats
     * require. Falls back to a best-effort derivation (covers DMs and forum
     * topics, but cannot reproduce `user:` for plain group chats).
     */
    private conversationKeyForTarget;
    /** Map the renderer's inline keyboard to grammY's `reply_markup` shape. */
    private toReplyMarkup;
}
/** Construct a Telegram `PlatformAdapter`. */
export declare function telegram(opts: TelegramAdapterOptions): TelegramAdapter;
//# sourceMappingURL=adapter.d.ts.map