import * as react_jsx_runtime from 'react/jsx-runtime';
import React, { ReactNode } from 'react';

type PushHandler = (data: unknown) => void;
/**
 * RPC Engine — communicates with the parent window (web platform) via postMessage.
 *
 * Security model:
 *   1. On init, the SDK sends { type: '__charx_rpc__', method: 'sdk.init' } to the parent.
 *   2. The platform responds with { type: '__charx_ready__', token, origin } — a per-session
 *      secret token that proves the parent is the legitimate platform.
 *   3. All subsequent outgoing RPC messages include the token.
 *   4. The platform validates the token on every call, rejecting unauthorised frames.
 *   5. Incoming messages are accepted only from window.parent (e.source check).
 *
 * Protocol (matches html-message.tsx):
 *   iframe → parent:  { type: '__charx_rpc__',          iframeId, token?, id?, method, args[] }
 *   parent → iframe:  { type: '__charx_ready__',         iframeId, token, origin }
 *   parent → iframe:  { type: '__charx_rpc_response__',  iframeId, id, result?, error? }
 *   parent → iframe:  { type: '__charx_push__',          event, data }
 */
declare class RpcEngine {
    private pending;
    private pushHandlers;
    private readonly iframeId;
    private readonly target;
    /** Session token issued by the platform after the init handshake */
    private _token;
    /** Platform's origin — used as targetOrigin for all outgoing messages after handshake */
    private _platformOrigin;
    /** Resolvers waiting for the __charx_ready__ handshake */
    private _readyResolvers;
    private _handshakeDone;
    constructor(target?: Window);
    private static _genId;
    private handleMessage;
    /**
     * Returns a Promise that resolves when the platform handshake completes.
     * Used by CharxSdk.init() to wait for the session token.
     */
    waitReady(): Promise<void>;
    get iframeIdValue(): string;
    /**
     * Two-way call — returns a Promise that resolves with the platform's response.
     * Rejects if the platform returns an error or if `timeoutMs` elapses with no response.
     */
    call<Resp = unknown>(method: string, args?: unknown[], timeoutMs?: number): Promise<Resp>;
    /** Fire-and-forget — no response expected. */
    post(method: string, args?: unknown[]): Promise<void>;
    /** Subscribe to push events sent by the platform */
    push(event: string, handler: PushHandler): () => void;
    /** Destroy the engine — rejects all pending calls and removes the message listener */
    destroy(): void;
}

interface Message {
    id: string;
    role: 'user' | 'assistant' | 'system';
    content: string;
    createdAt: number;
    tokenCount?: number;
    swipes?: string[];
    activeSwipe?: number;
    variables?: Record<string, unknown>;
}
interface SendOptions {
    onData?: (chunk: string) => void;
    onComplete?: (message: Message) => void;
    onError?: (error: Error) => void;
    onStart?: (payload: ChatStreamStartPayload) => void;
    model?: string;
    temperature?: number;
    injectedSystemPrompts?: string[];
    timeoutMs?: number;
    requestId?: string;
}
/** Options for sdk.chat.generateRaw() — silent background LLM call */
interface GenerateRawOptions {
    /** Override the model for this call */
    model?: string;
    temperature?: number;
    maxTokens?: number;
    /**
     * When true, prepend the character context (system prompt, worldbook, etc.)
     * from the current conversation. Defaults to true when conversationId is available.
     */
    includeCharacterContext?: boolean;
    timeoutMs?: number;
}
/** A message passed to generateRaw() as part of the messages array */
interface GenerateRawMessage {
    role: 'system' | 'user' | 'assistant';
    content: string;
}
interface ChatHistoryOptions {
    limit?: number;
    offset?: number;
    page?: number;
    pageSize?: number;
}
interface MessagesModule {
    list(params?: ChatHistoryOptions): Promise<Message[]>;
    getAll(): Promise<Message[]>;
    delete(id: string): Promise<void>;
    edit(id: string, content: string): Promise<Message>;
    /**
     * @deprecated Compatibility placeholder only.
     * Current creator preview and web chat hosts may reject this call.
     * Prefer regenerate(), continue(), edit(), or explicit message state in variables.
     */
    swipe(id: string, direction: 'left' | 'right'): Promise<Message>;
}
interface ChatStreamStartPayload {
    requestId?: string;
    userMessageId?: string | number;
    assistantMessageId?: string | number;
}
interface ChatSendTask {
    requestId: string;
    done: Promise<Message>;
    stop(): Promise<void>;
}
interface CharacterInfo {
    id: string | number;
    name: string;
    avatar?: string;
    displayIntro?: string;
    firstMes?: string;
    alternateGreetings?: string[];
    tags?: string[];
    creator?: string;
    version?: string | number;
}
interface PersonaInfo {
    id?: string | number;
    name?: string;
    avatar?: string;
    callName?: string;
    gender?: string;
    description?: string;
}
interface CharacterSettings {
    model?: string | null;
}
type VariableMap = Record<string, unknown>;
type Unsubscribe = () => void;
interface ToastOptions {
    text: string;
    type?: 'success' | 'error' | 'warning' | 'info';
    duration?: number;
    icon?: string;
}
/** ToastOptions 或可直接展示的简短文本值。 */
type ToastInput = ToastOptions | string | number | boolean;
interface PanelOptions {
    url: string;
    title?: string;
    mode?: 'fullscreen' | 'sidebar' | 'modal';
    width?: number | string;
}
/** PanelOptions 或扩展面板 URL 简写。 */
type PanelInput = PanelOptions | string;
interface AlertOptions {
    message: string;
    title?: string;
    confirmText?: string;
}
interface ConfirmOptions {
    message: string;
    title?: string;
    confirmText?: string;
    cancelText?: string;
}
interface PromptOptions {
    message: string;
    title?: string;
    placeholder?: string;
    defaultValue?: string;
}
interface SpeakOptions {
    voice?: 'character' | 'system' | string;
    speed?: number;
    pitch?: number;
}
interface BgmOptions {
    loop?: boolean;
    volume?: number;
    fadeIn?: number;
}
interface BgmStopOptions {
    fadeOut?: number;
}
interface SfxOptions {
    volume?: number;
}
interface SaveSlot {
    slot: number;
    description?: string;
    savedAt: number;
    snapshot?: Record<string, unknown>;
}
interface Achievement {
    id: string;
    name: string;
    description: string;
    unlockedAt?: number;
}
interface RankEntry {
    userId: string;
    username: string;
    score: number;
    rank: number;
}
interface WorldbookEntryState {
    entryKey: string;
    comment: string;
    /** The full text content of the entry — now included in getAll() response */
    content: string;
    /** Trigger keywords for this entry */
    keys: string[];
    enabled: boolean;
    baseEnabled: boolean;
    isOverridden: boolean;
    constant: boolean;
    insertionOrder: number;
}
interface ConversationWorldbookResponse {
    conversationId: number;
    characterId: number;
    entries: WorldbookEntryState[];
    totalCount: number;
    enabledCount: number;
}
type ChatStatus = 'idle' | 'sending' | 'streaming' | 'error';
interface UseChatReturn {
    messages: Message[];
    status: ChatStatus;
    error: Error | null;
    currentRequestId: string | null;
    currentAssistantMessageId: string | null;
    send: (message: string, options?: SendOptions) => void;
    sendStream: (message: string, options?: SendOptions) => ChatSendTask;
    stop: () => Promise<void>;
    regenerate: () => Promise<void>;
    continue: () => Promise<void>;
    deleteMessage: (id: string) => Promise<void>;
    editMessage: (id: string, content: string) => Promise<void>;
    /**
     * @deprecated Compatibility placeholder only.
     * Current creator preview and web chat hosts may reject this call.
     */
    swipeMessage: (id: string, direction: 'left' | 'right') => Promise<void>;
    generateRaw: (messages: GenerateRawMessage[], options?: GenerateRawOptions) => Promise<string>;
    injectPrompt: (content: string) => Promise<void>;
    insertSystemMessage: (content: string) => Promise<Message>;
    getConversationId: () => Promise<number>;
    loadMore: () => Promise<void>;
    hasMore: boolean;
}

declare class ChatModule {
    private rpc;
    readonly messages: MessagesModule;
    constructor(rpc: RpcEngine);
    private static genRequestId;
    /**
     * Send a message to the character.
     *
     * The platform processes the request through its normal chat flow.
     * `onData` fires for each streaming chunk; `onComplete` fires when the
     * stream finishes; `onError` fires if the generation fails.
     */
    send(message: string, options?: SendOptions): void;
    stop(): Promise<void>;
    regenerate(): Promise<void>;
    continue(): Promise<void>;
    getInput(): Promise<string>;
    setInput(text: string): Promise<void>;
    /** Set the active greeting index before the first user message is sent */
    setGreetingIndex(index: number): Promise<number>;
    /** Get the current active greeting index */
    getGreetingIndex(): Promise<number>;
    /** @deprecated Use setGreetingIndex(index) */
    setFirstMesIndex(index: number): Promise<number>;
    sendStream(message: string, options?: SendOptions): ChatSendTask;
    /**
     * Inject a system prompt into the next user-facing generation call.
     * Equivalent to SillyTavern injectPrompts().
     * The injected prompt is cleared automatically after the next chat.send().
     */
    injectPrompt(content: string): Promise<void>;
    /**
     * Insert a system message into the conversation without triggering AI generation.
     * Equivalent to SillyTavern createChatMessages() with role=system.
     */
    insertSystemMessage(content: string): Promise<Message>;
    /** Get the current conversation ID */
    getConversationId(): Promise<number>;
    /**
     * Subscribe to conversation switch events.
     * Fires when the user navigates to a different conversation.
     * Equivalent to SillyTavern CHAT_CHANGED event.
     */
    onChatChanged(callback: (payload: {
        conversationId: number;
    }) => void): Unsubscribe;
    /**
     * Subscribe to message-updated events.
     * Fires when an assistant message is fully saved (stream complete) or updated.
     * Equivalent to SillyTavern MESSAGE_UPDATED event.
     */
    onMessageUpdated(callback: (message: Message) => void): Unsubscribe;
    /**
     * Subscribe to message-edited events.
     * Fires when a message is edited via sdk.chat.messages.edit().
     * Equivalent to SillyTavern MESSAGE_EDITED event.
     */
    onMessageEdited(callback: (message: Message) => void): Unsubscribe;
    /**
     * Silent background LLM generation — equivalent to SillyTavern generateRaw().
     * Calls the AI model without adding any messages to the chat history.
     * When includeCharacterContext is true (default), the character's system prompt
     * and worldbook are included in the request context.
     */
    generateRaw(messages: GenerateRawMessage[], options?: GenerateRawOptions): Promise<string>;
    /**
     * Subscribe to message-deleted events.
     * Fires when a message is deleted via sdk.chat.messages.delete().
     * Equivalent to SillyTavern MESSAGE_DELETED event.
     */
    onMessageDeleted(callback: (message: Message) => void): Unsubscribe;
}

declare class CharacterModule {
    private rpc;
    constructor(rpc: RpcEngine);
    getInfo(): Promise<CharacterInfo>;
    getPersona(): Promise<PersonaInfo | null>;
    getSettings(): Promise<CharacterSettings>;
}

declare class VariableModule {
    private rpc;
    private observedValues;
    constructor(rpc: RpcEngine);
    getAll(): Promise<VariableMap>;
    get<T = unknown>(key: string): Promise<T | null>;
    set<T = unknown>(key: string, value: T): Promise<void>;
    setMany(vars: VariableMap): Promise<void>;
    increment(key: string, delta?: number): Promise<number>;
    decrement(key: string, delta?: number): Promise<number>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    /**
     * Watch a single variable for changes pushed from the platform.
     * Requires the platform to send `{ type: '__charx_push__', event: 'variable.changed', data: { key, value } }`.
     */
    watch<T = unknown>(key: string, callback: (value: T, oldValue: T | undefined) => void): Unsubscribe;
    /**
     * Watch all variables — callback receives the full variable map on any change.
     * Re-fetches the complete map after each push event so the callback always
     * receives a consistent snapshot (the push payload is a single { key, value },
     * not the full map).
     */
    watchAll(callback: (vars: VariableMap) => void): Unsubscribe;
}

declare class StorageModule {
    private rpc;
    constructor(rpc: RpcEngine);
    set<T = unknown>(key: string, value: T): Promise<void>;
    get<T = unknown>(key: string): Promise<T | null>;
    getOrDefault<T = unknown>(key: string, defaultValue: T): Promise<T>;
    has(key: string): Promise<boolean>;
    remove(key: string): Promise<void>;
    clear(): Promise<void>;
    keys(): Promise<string[]>;
}

declare class UIModule {
    private rpc;
    constructor(rpc: RpcEngine);
    toast(options: ToastInput): Promise<void>;
    alert(options: AlertOptions): Promise<void>;
    alert(message: string): Promise<void>;
    confirm(options: ConfirmOptions): Promise<boolean>;
    confirm(message: string): Promise<boolean>;
    prompt(options: PromptOptions): Promise<string | null>;
    prompt(message: string, defaultValue?: string): Promise<string | null>;
    openPanel(options: PanelInput): Promise<void>;
    closePanel(): Promise<void>;
    hideChatInput(): Promise<void>;
    showChatInput(): Promise<void>;
    setTheme(theme: 'dark' | 'light' | 'system'): Promise<void>;
    scrollToBottom(): Promise<void>;
}

declare class BgmController {
    private rpc;
    constructor(rpc: RpcEngine);
    play(url: string, options?: BgmOptions): Promise<void>;
    stop(options?: BgmStopOptions): Promise<void>;
    pause(): Promise<void>;
    resume(): Promise<void>;
    setVolume(volume: number): Promise<void>;
}
declare class SfxController {
    private rpc;
    constructor(rpc: RpcEngine);
    play(url: string, options?: SfxOptions): Promise<void>;
    preload(urls: string[]): Promise<void>;
}
declare class MediaModule {
    private rpc;
    readonly bgm: BgmController;
    readonly sfx: SfxController;
    constructor(rpc: RpcEngine);
    speak(text: string, options?: SpeakOptions): Promise<void>;
    stopSpeak(): Promise<void>;
}

declare class GameAchievementsController {
    private rpc;
    constructor(rpc: RpcEngine);
    unlock(achievementId: string): Promise<void>;
    list(): Promise<Achievement[]>;
}
declare class GameRankingController {
    private rpc;
    constructor(rpc: RpcEngine);
    submit(score: number, options?: {
        category?: string;
    }): Promise<void>;
    getTop(options?: {
        limit?: number;
        category?: string;
    }): Promise<RankEntry[]>;
    getSelf(options?: {
        category?: string;
    }): Promise<RankEntry>;
}
declare class GameModule {
    private rpc;
    readonly achievements: GameAchievementsController;
    readonly ranking: GameRankingController;
    constructor(rpc: RpcEngine);
    save(options: {
        slot: number;
        description?: string;
    }): Promise<void>;
    load(options: {
        slot: number;
    }): Promise<Record<string, unknown>>;
    listSaves(): Promise<SaveSlot[]>;
    deleteSave(slot: number): Promise<void>;
    unlockAchievement(achievementId: string): Promise<void>;
    listAchievements(): Promise<Achievement[]>;
    submitScore(score: number, options?: {
        category?: string;
    }): Promise<void>;
    getTop(options?: {
        limit?: number;
        category?: string;
    }): Promise<RankEntry[]>;
    getSelfRank(options?: {
        category?: string;
    }): Promise<RankEntry>;
}

/**
 * Shared lightweight Markdown → HTML renderer.
 * Handles: bold+italic, bold, italic, inline code, line breaks.
 * All input is HTML-escaped first to prevent XSS.
 * Exported so MdRenderer and other consumers share one implementation.
 */
declare function renderMarkdown(text: string): string;
declare class UtilsModule {
    private _rpc;
    constructor(_rpc: RpcEngine);
    clipboard: {
        writeText: (text: string) => Promise<void>;
        readText: () => Promise<string>;
    };
    format: {
        /** Convert basic Markdown to safe HTML (bold, italic, inline code, line breaks). */
        markdown: typeof renderMarkdown;
        /** Escape arbitrary text so it is safe to inject into innerHTML. */
        sanitize: (html: string) => string;
    };
}

declare class WorldbookModule {
    private rpc;
    constructor(rpc: RpcEngine);
    /** 获取当前会话所有世界书条目状态 */
    getAll(): Promise<ConversationWorldbookResponse>;
    /** 启用某个条目 */
    enable(entryKey: string): Promise<void>;
    /** 禁用某个条目 */
    disable(entryKey: string): Promise<void>;
    /** 批量设置多个条目启用状态 */
    batchToggle(entries: Array<{
        entryKey: string;
        enabled: boolean;
    }>): Promise<void>;
    /** 覆盖某个条目的内容（仅对当前会话有效） */
    setContent(entryKey: string, content: string): Promise<void>;
    /** 清除某个条目的内容覆盖（恢复模板内容） */
    clearContent(entryKey: string): Promise<void>;
    /** 重置所有覆盖（恢复全部条目到模板默认状态） */
    reset(): Promise<void>;
}

declare class CharxSdk {
    private static instance;
    private rpc;
    private _ready;
    private _chat?;
    private _character?;
    private _variable?;
    private _storage?;
    private _ui?;
    private _media?;
    private _game?;
    private _utils?;
    private _worldbook?;
    private constructor();
    static getInstance(): CharxSdk;
    get isReady(): boolean;
    /**
     * Initialize the SDK.
     * Sends sdk.init to the platform and waits for a __charx_ready__ handshake
     * response containing a session token.  All subsequent RPC calls carry this
     * token — the platform rejects calls from frames that skipped the handshake.
     *
     * Throws if the platform does not respond within 8 seconds (not embedded in
     * the platform, or running in a non-iframe context).
     */
    init(): Promise<void>;
    getRpc(): RpcEngine;
    get chat(): ChatModule;
    get character(): CharacterModule;
    get variable(): VariableModule;
    get storage(): StorageModule;
    get ui(): UIModule;
    get media(): MediaModule;
    get game(): GameModule;
    get utils(): UtilsModule;
    get worldbook(): WorldbookModule;
}

interface CharxProviderProps {
    children: ReactNode;
    /** Rendered while the SDK handshake is in progress */
    fallback?: ReactNode;
    /** Rendered if SDK init fails (e.g. not inside the platform iframe) */
    errorFallback?: (error: Error) => ReactNode;
}
declare function CharxProvider({ children, fallback, errorFallback }: CharxProviderProps): react_jsx_runtime.JSX.Element;
declare function useCharx(): CharxSdk;

declare function useChat(): UseChatReturn;
declare function useVariable<T = unknown>(key: string, defaultValue: T): [T, (v: T) => Promise<void>];
declare function useVariables(): Record<string, unknown>;
declare function useCharacter(): CharacterInfo | null;
declare function usePersona(): PersonaInfo | null;
declare function useStorage<T = unknown>(key: string, defaultValue: T): [T, (v: T) => Promise<void>, () => Promise<void>];

interface MessageListProps {
    messages: Message[];
    onLoadMore?: () => void;
    renderMessage?: (message: Message, isStreaming: boolean) => React.ReactNode;
    isStreaming?: boolean;
}
declare function MessageItem({ message, isStreaming }: {
    message: Message;
    isStreaming?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function MessageList({ messages, onLoadMore, renderMessage, isStreaming }: MessageListProps): react_jsx_runtime.JSX.Element;
declare const Thread: {
    MessageList: typeof MessageList;
    MessageItem: typeof MessageItem;
};

interface MdRendererProps {
    content: string;
    className?: string;
    style?: React.CSSProperties;
}
declare function MdRenderer({ content, className, style }: MdRendererProps): react_jsx_runtime.JSX.Element;

export { CharxProvider, MdRenderer, Thread, useCharacter, useCharx, useChat, usePersona, useStorage, useVariable, useVariables };