import EventEmitter from "eventemitter3";
import { SpeechConfig, Mood, ConversationId, Message } from "./types";
import Conversation, { ConversationOptions } from "./Conversation";
interface GlobalOptions {
    charismaUrl?: string;
}
interface PlaythroughTokenOptions {
    storyId: number;
    version?: number;
    userToken?: string;
}
interface CharismaOptions extends GlobalOptions {
    speechConfig?: SpeechConfig;
}
declare type ConversationToJoin = ConversationId | {
    conversationId: ConversationId;
    options: ConversationOptions;
};
interface SetMoodResult {
    characterId: number;
    mood: Mood;
}
interface GetPlaythroughInfoResult {
    characterMoods: {
        id: number;
        name: string;
        mood: Mood;
    }[];
    memories: {
        id: number;
        recallValue: string;
        saveValue: string | null;
    }[];
    impacts: {
        id: number;
        impact: string;
    }[];
}
interface GetMessageHistoryResult {
    messages: Message[];
}
interface CharismaEvents {
    connect: [];
    reconnect: [];
    reconnecting: [];
    disconnect: [];
    error: [any];
    ready: [];
    problem: [{
        type: string;
        error: string;
    }];
}
declare class Charisma extends EventEmitter<CharismaEvents> {
    static charismaUrl: string;
    static createPlaythroughToken(options: PlaythroughTokenOptions): Promise<string>;
    static createConversation(token: string): Promise<ConversationId>;
    static createCharacterConversation(token: string, characterId: number): Promise<ConversationId>;
    static getMessageHistory(token: string, conversationId?: number | undefined, minEventId?: string | undefined): Promise<GetMessageHistoryResult>;
    static getPlaythroughInfo(token: string): Promise<GetPlaythroughInfoResult>;
    static setMood(token: string, characterIdOrName: number | string, modifier: Partial<Mood>): Promise<SetMoodResult>;
    static setMemory(token: string, memoryIdOrRecallValue: number | string, saveValue: string | null): Promise<void>;
    static restartFromEpisodeId(token: string, episodeId: number): Promise<void>;
    static restartFromEpisodeIndex(token: string, episodeIndex: number): Promise<void>;
    private eventQueue;
    private token;
    private charismaUrl;
    private socket;
    private activeConversations;
    constructor(token: string, options?: CharismaOptions);
    createConversation(): Promise<ConversationId>;
    createCharacterConversation(characterId: number): Promise<ConversationId>;
    getMessageHistory(conversationId?: number | undefined, minEventId?: string | undefined): Promise<GetMessageHistoryResult>;
    getPlaythroughInfo(): Promise<GetPlaythroughInfoResult>;
    setMemory(memoryIdOrRecallValue: number | string, saveValue: string | null): Promise<void>;
    setMood(characterIdOrName: number | string, modifier: Mood): Promise<SetMoodResult>;
    restartFromEpisodeId(episodeId: number): Promise<void>;
    restartFromEpisodeIndex(episodeIndex: number): Promise<void>;
    joinConversation: (conversationId: number, options?: ConversationOptions | undefined) => Conversation;
    joinConversations: (conversations: ConversationToJoin[]) => Promise<Conversation[]>;
    leaveConversation: (conversationId: number) => void;
    getConversation: (conversationId: number) => Conversation | undefined;
    addOutgoingEvent: (eventName: string, ...eventData: unknown[]) => void;
    connect: () => void;
    cleanup: () => void;
    private onConnect;
    private onReconnect;
    private onReconnecting;
    private onError;
    private onDisconnect;
    private onStatus;
    private onProblem;
    private onStartTyping;
    private onStopTyping;
    private onMessage;
    private onEpisodeComplete;
}
export default Charisma;