import { ThreadApi } from '../api/thread/ThreadApi';
import { EventDispatcher } from '../EventDispatcher';
import { EndpointApiEvent, ListOptions, Message, PagingList, Thread, UserWithPubKey } from '../types';
import { EventsByChannel, SubscribeForChannel, ThreadEvents, ThreadMessageEvents } from '../types/events';
import { Endpoint } from './Endpoint';
import { ThreadMessagePayload } from '../types/thread';
/**
 * Helper wrapper around raw Wasm bindings. Manages all the necessary IDs exposing high level Threads API.
 *
 */
export declare class ThreadClient {
    private _threadId;
    get threadId(): string;
    private _endpoint;
    private _eventDispatcher;
    /**
     * @param {string} threadId
     * @param {Endpoint} platform {@link Endpoint `Endpoint`} instance
     *
     */
    constructor(threadId: string, platform: Endpoint, eventDispatcher: EventDispatcher);
    /**
     * Gets Thread API from current Endpoint instance.
     * @returns {Promise<ThreadApi>} {@link ThreadApi `Promise<ThreadApi>`}
     */
    private getApi;
    /**
     * Creates a new Thread in current Context.
     * @param {ThreadApi} threadApi {@link ThreadApi `ThreadApi`} instance
     * @param {Object} newThread
     * @param {UserWithPubKey[]} newThread.users list of {@link UserWithPubKey `UserWithPubKey`} objects which indicates who will have access to the updated Thread
     * @param {UserWithPubKey[]} newThread.managers list of {@link UserWithPubKey `UserWithPubKey`} objects which indicates who will have access (and management rights) to the updated Thread
     * @param {Uint8Array} newThread.publicMeta - public metadata of the Thread
     * @param {Uint8Array} newThread.privateMeta - private metadata of the Thread
     * @returns {Promise<string>} promise of newly created Thread ID
     */
    static createThread(threadApi: ThreadApi, newThread: {
        contextId: string;
        users: UserWithPubKey[];
        managers: UserWithPubKey[];
        publicMeta?: Uint8Array;
        privateMeta?: Uint8Array;
    }): Promise<string>;
    /**
     * Returns a list of Threads in given Context.
     * @param {ThreadApi} threadApi {@link ThreadApi `ThreadApi`} instance
     * @param {string} contextId - ID of the Context to get Threads from
     * @param {number} pageIndex
     * @param {ListOptions} options optional {@link ListOptions `options`} object
     * @returns {Promise<PagingList<Thread>>} - promise of {@link PagingList `PagingList<Thread>`}
     */
    static getThreads(threadApi: ThreadApi, contextId: string, pageIndex?: number, options?: ListOptions): Promise<PagingList<Thread>>;
    /**
     * Fetches info about current Thread.
     * @returns {Promise<Thread>} {@link Thread `Thread`} object
     */
    getThreadInfo(): Promise<Thread>;
    /**
     * Updates Thread by overriding fields with new ones.
     * While updating, the server will check version number. Updates of Thread with different
     * version number will be rejected.
     * Version number is incremented after every update.
     *
     * @param {Object} updatedData
     * @param {UserWithPubKey[]} updatedData.users - list of users with access to the Thread
     * @param {UserWithPubKey[]} updatedData.managers - list of users with permissions to modify the Thread
     * @param {Uint8Array} updatedData.publicMeta  public (unencrypted) metadata
     * @param {Uint8Array} updatedData.privateMeta  (encrypted) metadata
     * @param {Object=} [updatedData.options]
     * @param {boolean} [updatedData.options.force] - optional flag to generate a new key ID for the Thread
     * @param {boolean} [updatedData.options.forceGenerateNewKey] - optional flag allowing new users to access old data
     */
    updateThread(updatedData: {
        users: UserWithPubKey[];
        managers: UserWithPubKey[];
        publicMeta?: Uint8Array;
        privateMeta?: Uint8Array;
        version: number;
        options?: {
            force?: boolean;
            forceGenerateNewKey?: boolean;
        };
    }): Promise<void>;
    /**
     * Deletes current Thread from Context.
     * @returns {Promise<void>} a promise that resolves with void
     */
    deleteThread(): Promise<void>;
    /**
     * Sends a message to Thread.
     * @param {ThreadMessagePayload} newMessage - {@link ThreadMessagePayload `ThreadMessagePayload`}
     * @returns {Promise<string>} promise of new messages's `messageId`
     */
    sendMessage(newMessage: ThreadMessagePayload): Promise<string>;
    /**
     * Returns list of messages inside Thread.
     * @param {number} pageIndex
     * @param {ListOptions} options optional {@link ListOptions options} object
     * @returns {Promise<PagingList<Message>>}  {@link PagingList `PagingList<Message>`}
     */
    getMessages(pageIndex?: number, options?: ListOptions): Promise<PagingList<Message>>;
    /**
     * Returns message with matching `messageId`.
     * @param {ThreadApi} threadApi {@link ThreadApi `ThreadApi`} instance
     * @param {string} messageId ID of the message to get
     * @returns {Promise<Message>} {@link Message `Promise<Message>`}
     */
    static getMessage(threadApi: ThreadApi, messageId: string): Promise<Message>;
    /**
     * Deletes message with matching `messageId`.
     * @param {ThreadApi} threadApi {@link ThreadApi `ThreadApi`} instance
     * @param {string} messageId ID of message to delete
     * @returns {Promise<void>} a promise that resolves with void
     */
    static deleteMessage(threadApi: ThreadApi, messageId: string): Promise<void>;
    private getOn;
    /**
     * Subscribes to message events in given Thread:
     * - `threadNewMessage`
     * - `threadMessageDeleted`
     * - `threadMessageUpdated`
     * @returns  {Promise<SubscribeForChannel<'threadMessages'>>} {@link SubscribeForChannel<'threadMessages'> `Promise<SubscribeForChannel<'threadMessages'>>`}
     */
    subscribeToMessageEvents(): Promise<SubscribeForChannel<'threadMessages'>>;
    /**
     * Unsubscribes from  message-related events in the Thread.
     * @returns {Promise<void>} a promise that resolves with void
     */
    unsubscribeFromMessageEvents(): Promise<void>;
    /**
     * Registers an event listener for Thread message-related events.
     *
     * @template T
     * @param {T & EventsByChannel<'threadMessages'>} eventType - type of event to listen for
     * @param {function(Extract<EndpointApiEvent, { type: T }>): void} callback - callback function to execute when the event occurs
     * @returns {Promise<{on: SubscribeForChannel<'threadMessages'>, removeEventListener: function() void}>} object containing the `on` function for chaining and `removeEventListener` to unregister the event listener
     */
    on<T extends EndpointApiEvent['type'] & EventsByChannel<'threadMessages'>>(eventType: T, callback: (payload: Extract<ThreadMessageEvents, {
        type: T;
    }>) => void): SubscribeForChannel<'threadMessages'> & {
        removeEventListener: () => void;
    };
    private static getOn;
    /**
     * Subscribes to events related to Threads:
     *  - `threadCreated`
     *  - `threadDeleted`
     *  - `threadStatsChanged`
     *  - `threadUpdated`
     * @param {ThreadApi} api - instance of Thread API
     * @param {EventDispatcher} eventDispatcher {@link EventDispatcher eventDispatcher}
     * @returns {Promise<SubscribeForChannel<'thread'>>} {@link SubscribeForChannel `SubscribeForChannel<'thread'>`}
     */
    static subscribeToThreadEvents(api: ThreadApi, eventDispatcher: EventDispatcher): Promise<SubscribeForChannel<'thread'>>;
    /**
     * Unsubscribes from events related to the Thread.
     *
     * @param {ThreadApi} threadApi - instance of Thread API
     * @param {EventDispatcher} eventDispatcher {@link EventDispatcher eventDispatcher}
     * @returns {Promise<void>} a promise that resolves with void
     */
    static unsubscribeFromThreadEvents(threadApi: ThreadApi, eventDispatcher: EventDispatcher): Promise<void>;
    /**
     * Registers an event listener for Thread-related events.
     *
     * @template T
     * @param {T & EventsByChannel<'thread'>} eventType - type of event to listen for
     * @param {function(Extract<EndpointApiEvent, { type: T }>): void} callback - callback function to execute when the event occurs
     * @returns {Promise<{on: SubscribeForChannel<'thread'>, removeEventListener: function() void}>} object containing the `on` function for chaining and `removeEventListener` to unregister the event listener
     */
    static on<T extends EndpointApiEvent['type'] & EventsByChannel<'thread'>>(eventDispatcher: EventDispatcher, eventType: T, callback: (payload: Extract<ThreadEvents, {
        type: T;
    }>) => void): SubscribeForChannel<'thread'> & {
        removeEventListener: () => void;
    };
}