/// <reference types="node" />
import { ChannelState } from './channel_state';
import { StreamChat } from './client';
import { APIResponse, BanUserOptions, ChannelAPIResponse, ChannelData, ChannelUpdateOptions, ChannelMemberAPIResponse, ChannelQueryOptions, ChannelResponse, DeleteChannelAPIResponse, Event, EventAPIResponse, EventHandler, EventTypes, FormatMessageResponse, GetMultipleMessagesAPIResponse, GetReactionsAPIResponse, GetRepliesAPIResponse, InviteOptions, MarkReadOptions, MemberSort, Message, MessageFilters, MessageResponse, MessageSetType, MuteChannelAPIResponse, PartialUpdateChannel, PartialUpdateChannelAPIResponse, QueryMembersOptions, Reaction, ReactionAPIResponse, SearchAPIResponse, SearchOptions, SendMessageAPIResponse, TruncateChannelAPIResponse, TruncateOptions, UpdateChannelAPIResponse, UserFilters, UserResponse, ExtendableGenerics, DefaultGenerics, PinnedMessagePaginationOptions, PinnedMessagesSort, MessagePaginationOptions } from './types';
import { Role } from './permissions';
/**
 * Channel - The Channel class manages it's own state.
 */
export declare class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
    _client: StreamChat<StreamChatGenerics>;
    type: string;
    id: string | undefined;
    data: ChannelData<StreamChatGenerics> | ChannelResponse<StreamChatGenerics> | undefined;
    _data: ChannelData<StreamChatGenerics> | ChannelResponse<StreamChatGenerics>;
    cid: string;
    listeners: {
        [key: string]: (string | EventHandler<StreamChatGenerics>)[];
    };
    state: ChannelState<StreamChatGenerics>;
    initialized: boolean;
    lastKeyStroke?: Date;
    lastTypingEvent: Date | null;
    isTyping: boolean;
    disconnected: boolean;
    /**
     * constructor - Create a channel
     *
     * @param {StreamChat<StreamChatGenerics>} client the chat client
     * @param {string} type  the type of channel
     * @param {string} [id]  the id of the chat
     * @param {ChannelData<StreamChatGenerics>} data any additional custom params
     *
     * @return {Channel<StreamChatGenerics>} Returns a new uninitialized channel
     */
    constructor(client: StreamChat<StreamChatGenerics>, type: string, id: string | undefined, data: ChannelData<StreamChatGenerics>);
    /**
     * getClient - Get the chat client for this channel. If client.disconnect() was called, this function will error
     *
     * @return {StreamChat<StreamChatGenerics>}
     */
    getClient(): StreamChat<StreamChatGenerics>;
    /**
     * getConfig - Get the configs for this channel type
     *
     * @return {Record<string, unknown>}
     */
    getConfig(): import("./types").ChannelConfigWithInfo<StreamChatGenerics> | undefined;
    /**
     * sendMessage - Send a message to this channel
     *
     * @param {Message<StreamChatGenerics>} message The Message object
     * @param {boolean} [options.skip_enrich_url] Do not try to enrich the URLs within message
     * @param {boolean} [options.skip_push] Skip sending push notifications
     *
     * @return {Promise<SendMessageAPIResponse<StreamChatGenerics>>} The Server Response
     */
    sendMessage(message: Message<StreamChatGenerics>, options?: {
        skip_enrich_url?: boolean;
        skip_push?: boolean;
    }): Promise<SendMessageAPIResponse<StreamChatGenerics>>;
    sendFile(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse<StreamChatGenerics>): Promise<import("./types").SendFileAPIResponse>;
    sendImage(uri: string | NodeJS.ReadableStream | File, name?: string, contentType?: string, user?: UserResponse<StreamChatGenerics>): Promise<import("./types").SendFileAPIResponse>;
    deleteFile(url: string): Promise<APIResponse>;
    deleteImage(url: string): Promise<APIResponse>;
    /**
     * sendEvent - Send an event on this channel
     *
     * @param {Event<StreamChatGenerics>} event for example {type: 'message.read'}
     *
     * @return {Promise<EventAPIResponse<StreamChatGenerics>>} The Server Response
     */
    sendEvent(event: Event<StreamChatGenerics>): Promise<EventAPIResponse<StreamChatGenerics>>;
    /**
     * search - Query messages
     *
     * @param {MessageFilters<StreamChatGenerics> | string}  query search query or object MongoDB style filters
     * @param {{client_id?: string; connection_id?: string; query?: string; message_filter_conditions?: MessageFilters<StreamChatGenerics>}} options Option object, {user_id: 'tommaso'}
     *
     * @return {Promise<SearchAPIResponse<StreamChatGenerics>>} search messages response
     */
    search(query: MessageFilters<StreamChatGenerics> | string, options?: SearchOptions<StreamChatGenerics> & {
        client_id?: string;
        connection_id?: string;
        message_filter_conditions?: MessageFilters<StreamChatGenerics>;
        query?: string;
    }): Promise<SearchAPIResponse<StreamChatGenerics>>;
    /**
     * queryMembers - Query Members
     *
     * @param {UserFilters<StreamChatGenerics>}  filterConditions object MongoDB style filters
     * @param {MemberSort<StreamChatGenerics>} [sort] Sort options, for instance [{created_at: -1}].
     * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
     * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
     *
     * @return {Promise<ChannelMemberAPIResponse<StreamChatGenerics>>} Query Members response
     */
    queryMembers(filterConditions: UserFilters<StreamChatGenerics>, sort?: MemberSort<StreamChatGenerics>, options?: QueryMembersOptions): Promise<ChannelMemberAPIResponse<StreamChatGenerics>>;
    /**
     * sendReaction - Send a reaction about a message
     *
     * @param {string} messageID the message id
     * @param {Reaction<StreamChatGenerics>} reaction the reaction object for instance {type: 'love'}
     * @param {{ enforce_unique?: boolean, skip_push?: boolean }} [options] Option object, {enforce_unique: true, skip_push: true} to override any existing reaction or skip sending push notifications
     *
     * @return {Promise<ReactionAPIResponse<StreamChatGenerics>>} The Server Response
     */
    sendReaction(messageID: string, reaction: Reaction<StreamChatGenerics>, options?: {
        enforce_unique?: boolean;
        skip_push?: boolean;
    }): Promise<ReactionAPIResponse<StreamChatGenerics>>;
    /**
     * deleteReaction - Delete a reaction by user and type
     *
     * @param {string} messageID the id of the message from which te remove the reaction
     * @param {string} reactionType the type of reaction that should be removed
     * @param {string} [user_id] the id of the user (used only for server side request) default null
     *
     * @return {Promise<ReactionAPIResponse<StreamChatGenerics>>} The Server Response
     */
    deleteReaction(messageID: string, reactionType: string, user_id?: string): Promise<ReactionAPIResponse<StreamChatGenerics>>;
    /**
     * update - Edit the channel's custom properties
     *
     * @param {ChannelData<StreamChatGenerics>} channelData The object to update the custom properties of this channel with
     * @param {Message<StreamChatGenerics>} [updateMessage] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    update(channelData?: Partial<ChannelData<StreamChatGenerics>> | Partial<ChannelResponse<StreamChatGenerics>>, updateMessage?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * updatePartial - partial update channel properties
     *
     * @param {PartialUpdateChannel<StreamChatGenerics>} partial update request
     *
     * @return {Promise<PartialUpdateChannelAPIResponse<StreamChatGenerics>>}
     */
    updatePartial(update: PartialUpdateChannel<StreamChatGenerics>): Promise<PartialUpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * enableSlowMode - enable slow mode
     *
     * @param {number} coolDownInterval the cooldown interval in seconds
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    enableSlowMode(coolDownInterval: number): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * disableSlowMode - disable slow mode
     *
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    disableSlowMode(): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * delete - Delete the channel. Messages are permanently removed.
     *
     * @param {boolean} [options.hard_delete] Defines if the channel is hard deleted or not
     *
     * @return {Promise<DeleteChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    delete(options?: {
        hard_delete?: boolean;
    }): Promise<DeleteChannelAPIResponse<StreamChatGenerics>>;
    /**
     * truncate - Removes all messages from the channel
     * @param {TruncateOptions<StreamChatGenerics>} [options] Defines truncation options
     * @return {Promise<TruncateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    truncate(options?: TruncateOptions<StreamChatGenerics>): Promise<TruncateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * acceptInvite - accept invitation to the channel
     *
     * @param {InviteOptions<StreamChatGenerics>} [options] The object to update the custom properties of this channel with
     *
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    acceptInvite(options?: InviteOptions<StreamChatGenerics>): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * rejectInvite - reject invitation to the channel
     *
     * @param {InviteOptions<StreamChatGenerics>} [options] The object to update the custom properties of this channel with
     *
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    rejectInvite(options?: InviteOptions<StreamChatGenerics>): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * addMembers - add members to the channel
     *
     * @param {{user_id: string, channel_role?: Role}[]} members An array of members to add to the channel
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    addMembers(members: string[] | {
        user_id: string;
        channel_role?: Role;
    }[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * addModerators - add moderators to the channel
     *
     * @param {string[]} members An array of member identifiers
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    addModerators(members: string[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * assignRoles - sets member roles in a channel
     *
     * @param {{channel_role: Role, user_id: string}[]} roles List of role assignments
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    assignRoles(roles: {
        channel_role: Role;
        user_id: string;
    }[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * inviteMembers - invite members to the channel
     *
     * @param {{user_id: string, channel_role?: Role}[]} members An array of members to invite to the channel
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    inviteMembers(members: {
        user_id: string;
        channel_role?: Role;
    }[] | string[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * removeMembers - remove members from channel
     *
     * @param {string[]} members An array of member identifiers
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    removeMembers(members: string[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * demoteModerators - remove moderator role from channel members
     *
     * @param {string[]} members An array of member identifiers
     * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    demoteModerators(members: string[], message?: Message<StreamChatGenerics>, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * _update - executes channel update request
     * @param payload Object Update Channel payload
     * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
     * TODO: introduce new type instead of Object in the next major update
     */
    _update(payload: Object): Promise<UpdateChannelAPIResponse<StreamChatGenerics>>;
    /**
     * mute - mutes the current channel
     * @param {{ user_id?: string, expiration?: string }} opts expiration in minutes or user_id
     * @return {Promise<MuteChannelAPIResponse<StreamChatGenerics>>} The server response
     *
     * example with expiration:
     * await channel.mute({expiration: moment.duration(2, 'weeks')});
     *
     * example server side:
     * await channel.mute({user_id: userId});
     *
     */
    mute(opts?: {
        expiration?: number;
        user_id?: string;
    }): Promise<MuteChannelAPIResponse<StreamChatGenerics>>;
    /**
     * unmute - mutes the current channel
     * @param {{ user_id?: string}} opts user_id
     * @return {Promise<APIResponse>} The server response
     *
     * example server side:
     * await channel.unmute({user_id: userId});
     */
    unmute(opts?: {
        user_id?: string;
    }): Promise<APIResponse>;
    /**
     * muteStatus - returns the mute status for the current channel
     * @return {{ muted: boolean; createdAt: Date | null; expiresAt: Date | null }} { muted: true | false, createdAt: Date | null, expiresAt: Date | null}
     */
    muteStatus(): {
        createdAt: Date | null;
        expiresAt: Date | null;
        muted: boolean;
    };
    sendAction(messageID: string, formData: Record<string, string>): Promise<SendMessageAPIResponse<StreamChatGenerics>>;
    /**
     * keystroke - First of the typing.start and typing.stop events based on the users keystrokes.
     * Call this on every keystroke
     * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
     * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
     */
    keystroke(parent_id?: string): Promise<void>;
    /**
     * stopTyping - Sets last typing to null and sends the typing.stop event
     * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
     * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
     */
    stopTyping(parent_id?: string): Promise<void>;
    /**
     * lastMessage - return the last message, takes into account that last few messages might not be perfectly sorted
     *
     * @return {ReturnType<ChannelState<StreamChatGenerics>['formatMessage']> | undefined} Description
     */
    lastMessage(): FormatMessageResponse<StreamChatGenerics>;
    /**
     * markRead - Send the mark read event for this user, only works if the `read_events` setting is enabled
     *
     * @param {MarkReadOptions<StreamChatGenerics>} data
     * @return {Promise<EventAPIResponse<StreamChatGenerics> | null>} Description
     */
    markRead(data?: MarkReadOptions<StreamChatGenerics>): Promise<EventAPIResponse<StreamChatGenerics> | null>;
    /**
     * clean - Cleans the channel state and fires stop typing if needed
     */
    clean(): void;
    /**
     * watch - Loads the initial channel state and watches for changes
     *
     * @param {ChannelQueryOptions<StreamChatGenerics>} options additional options for the query endpoint
     *
     * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} The server response
     */
    watch(options?: ChannelQueryOptions<StreamChatGenerics>): Promise<ChannelAPIResponse<StreamChatGenerics>>;
    /**
     * stopWatching - Stops watching the channel
     *
     * @return {Promise<APIResponse>} The server response
     */
    stopWatching(): Promise<APIResponse>;
    /**
     * getReplies - List the message replies for a parent message
     *
     * @param {string} parent_id The message parent id, ie the top of the thread
     * @param {MessagePaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
     *
     * @return {Promise<GetRepliesAPIResponse<StreamChatGenerics>>} A response with a list of messages
     */
    getReplies(parent_id: string, options: MessagePaginationOptions & {
        user?: UserResponse<StreamChatGenerics>;
        user_id?: string;
    }): Promise<GetRepliesAPIResponse<StreamChatGenerics>>;
    /**
     * getPinnedMessages - List list pinned messages of the channel
     *
     * @param {PinnedMessagePaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
     * @param {PinnedMessagesSort} sort defines sorting direction of pinned messages
     *
     * @return {Promise<GetRepliesAPIResponse<StreamChatGenerics>>} A response with a list of messages
     */
    getPinnedMessages(options: PinnedMessagePaginationOptions & {
        user?: UserResponse<StreamChatGenerics>;
        user_id?: string;
    }, sort?: PinnedMessagesSort): Promise<GetRepliesAPIResponse<StreamChatGenerics>>;
    /**
     * getReactions - List the reactions, supports pagination
     *
     * @param {string} message_id The message id
     * @param {{ limit?: number; offset?: number }} options The pagination options
     *
     * @return {Promise<GetReactionsAPIResponse<StreamChatGenerics>>} Server response
     */
    getReactions(message_id: string, options: {
        limit?: number;
        offset?: number;
    }): Promise<GetReactionsAPIResponse<StreamChatGenerics>>;
    /**
     * getMessagesById - Retrieves a list of messages by ID
     *
     * @param {string[]} messageIds The ids of the messages to retrieve from this channel
     *
     * @return {Promise<GetMultipleMessagesAPIResponse<StreamChatGenerics>>} Server response
     */
    getMessagesById(messageIds: string[]): Promise<GetMultipleMessagesAPIResponse<StreamChatGenerics>>;
    /**
     * lastRead - returns the last time the user marked the channel as read if the user never marked the channel as read, this will return null
     * @return {Date | null | undefined}
     */
    lastRead(): Date | null | undefined;
    _countMessageAsUnread(message: FormatMessageResponse<StreamChatGenerics> | MessageResponse<StreamChatGenerics>): boolean;
    /**
     * countUnread - Count of unread messages
     *
     * @param {Date | null} [lastRead] lastRead the time that the user read a message, defaults to current user's read state
     *
     * @return {number} Unread count
     */
    countUnread(lastRead?: Date | null): number;
    /**
     * countUnreadMentions - Count the number of unread messages mentioning the current user
     *
     * @return {number} Unread mentions count
     */
    countUnreadMentions(): number;
    /**
     * create - Creates a new channel
     *
     * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} The Server Response
     */
    create: () => Promise<ChannelAPIResponse<StreamChatGenerics>>;
    /**
     * query - Query the API, get messages, members or other channel fields
     *
     * @param {ChannelQueryOptions<StreamChatGenerics>} options The query options
     * @param {MessageSetType} messageSetToAddToIfDoesNotExist It's possible to load disjunct sets of a channel's messages into state, use `current` to load the initial channel state or if you want to extend the currently displayed messages, use `latest` if you want to load/extend the latest messages, `new` is used for loading a specific message and it's surroundings
     *
     * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} Returns a query response
     */
    query(options: ChannelQueryOptions<StreamChatGenerics>, messageSetToAddToIfDoesNotExist?: MessageSetType): Promise<ChannelAPIResponse<StreamChatGenerics>>;
    /**
     * banUser - Bans a user from a channel
     *
     * @param {string} targetUserID
     * @param {BanUserOptions<StreamChatGenerics>} options
     * @returns {Promise<APIResponse>}
     */
    banUser(targetUserID: string, options: BanUserOptions<StreamChatGenerics>): Promise<APIResponse>;
    /**
     * hides the channel from queryChannels for the user until a message is added
     * If clearHistory is set to true - all messages will be removed for the user
     *
     * @param {string | null} userId
     * @param {boolean} clearHistory
     * @returns {Promise<APIResponse>}
     */
    hide(userId?: string | null, clearHistory?: boolean): Promise<APIResponse>;
    /**
     * removes the hidden status for a channel
     *
     * @param {string | null} userId
     * @returns {Promise<APIResponse>}
     */
    show(userId?: string | null): Promise<APIResponse>;
    /**
     * unbanUser - Removes the bans for a user on a channel
     *
     * @param {string} targetUserID
     * @returns {Promise<APIResponse>}
     */
    unbanUser(targetUserID: string): Promise<APIResponse>;
    /**
     * shadowBan - Shadow bans a user from a channel
     *
     * @param {string} targetUserID
     * @param {BanUserOptions<StreamChatGenerics>} options
     * @returns {Promise<APIResponse>}
     */
    shadowBan(targetUserID: string, options: BanUserOptions<StreamChatGenerics>): Promise<APIResponse>;
    /**
     * removeShadowBan - Removes the shadow ban for a user on a channel
     *
     * @param {string} targetUserID
     * @returns {Promise<APIResponse>}
     */
    removeShadowBan(targetUserID: string): Promise<APIResponse>;
    /**
     * on - Listen to events on this channel.
     *
     * channel.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
     * or
     * channel.on(event => {console.log(event.type)})
     *
     * @param {EventHandler<StreamChatGenerics> | EventTypes} callbackOrString  The event type to listen for (optional)
     * @param {EventHandler<StreamChatGenerics>} [callbackOrNothing] The callback to call
     */
    on(eventType: EventTypes, callback: EventHandler<StreamChatGenerics>): {
        unsubscribe: () => void;
    };
    on(callback: EventHandler<StreamChatGenerics>): {
        unsubscribe: () => void;
    };
    /**
     * off - Remove the event handler
     *
     */
    off(eventType: EventTypes, callback: EventHandler<StreamChatGenerics>): void;
    off(callback: EventHandler<StreamChatGenerics>): void;
    _handleChannelEvent(event: Event<StreamChatGenerics>): void;
    _callChannelListeners: (event: Event<StreamChatGenerics>) => void;
    /**
     * _channelURL - Returns the channel url
     *
     * @return {string} The channel url
     */
    _channelURL: () => string;
    _checkInitialized(): void;
    _initializeState(state: ChannelAPIResponse<StreamChatGenerics>, messageSetToAddToIfDoesNotExist?: MessageSetType): void;
    _disconnect(): void;
}
//# sourceMappingURL=channel.d.ts.map