stream-chat
Version:
JS SDK for the Stream Chat API
976 lines • 86.6 kB
TypeScript
/// <reference types="node" />
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import WebSocket from 'isomorphic-ws';
import { Channel } from './channel';
import { ClientState } from './client_state';
import { StableWSConnection } from './connection';
import { TokenManager } from './token_manager';
import { WSConnectionFallback } from './connection_fallback';
import { Campaign } from './campaign';
import { Segment } from './segment';
import { APIErrorResponse, APIResponse, AppSettings, AppSettingsAPIResponse, BannedUsersFilters, BannedUsersPaginationOptions, BannedUsersResponse, BannedUsersSort, BanUserOptions, BaseDeviceFields, BlockList, BlockListResponse, BlockUserAPIResponse, CampaignData, CampaignFilters, CampaignQueryOptions, CampaignResponse, CampaignSort, CastVoteAPIResponse, ChannelAPIResponse, ChannelData, ChannelFilters, ChannelMute, ChannelOptions, ChannelResponse, ChannelSort, ChannelStateOptions, CheckPushResponse, CheckSNSResponse, CheckSQSResponse, Configs, ConnectAPIResponse, CreateChannelOptions, CreateChannelResponse, CreateCommandOptions, CreateCommandResponse, CreateImportOptions, CreateImportResponse, CreateImportURLResponse, CreatePollAPIResponse, CreatePollData, CreatePollOptionAPIResponse, CustomPermissionOptions, DeactivateUsersOptions, DefaultGenerics, DeleteCommandResponse, DeleteUserOptions, Device, DeviceIdentifier, EndpointName, ErrorFromResponse, Event, EventHandler, ExportChannelOptions, ExportChannelRequest, ExportChannelResponse, ExportChannelStatusResponse, ExportUsersRequest, ExportUsersResponse, ExtendableGenerics, FlagMessageResponse, FlagReportsFilters, FlagReportsPaginationOptions, FlagReportsResponse, FlagsFilters, FlagsPaginationOptions, FlagsResponse, FlagUserResponse, GetBlockedUsersAPIResponse, GetCallTokenResponse, GetCampaignOptions, GetChannelTypeResponse, GetCommandResponse, GetImportResponse, GetMessageAPIResponse, GetMessageOptions, GetPollAPIResponse, GetPollOptionAPIResponse, GetRateLimitsResponse, GetThreadAPIResponse, GetThreadOptions, GetUnreadCountAPIResponse, GetUnreadCountBatchAPIResponse, ListChannelResponse, ListCommandsResponse, ListImportsPaginationOptions, ListImportsResponse, Logger, MarkChannelsReadOptions, MessageFilters, MessageFlagsFilters, MessageFlagsPaginationOptions, MessageFlagsResponse, MessageResponse, Mute, MuteUserOptions, MuteUserResponse, OGAttachment, OwnUserResponse, PartialMessageUpdate, PartialPollUpdate, PartialThreadUpdate, PartialUserUpdate, PermissionAPIResponse, PermissionsAPIResponse, PollAnswersAPIResponse, PollData, PollOptionData, PollSort, PollVote, PollVoteData, PollVotesAPIResponse, PushPreference, PushProvider, PushProviderConfig, PushProviderID, PushProviderListResponse, PushProviderUpsertResponse, QueryMessageHistoryFilters, QueryMessageHistoryOptions, QueryMessageHistoryResponse, QueryMessageHistorySort, QueryPollsFilters, QueryPollsOptions, QueryPollsResponse, QueryReactionsAPIResponse, QueryReactionsOptions, QuerySegmentsOptions, QuerySegmentTargetsFilter, QueryThreadsOptions, QueryVotesFilters, QueryVotesOptions, ReactionFilters, ReactionResponse, ReactionSort, ReactivateUserOptions, ReactivateUsersOptions, ReviewFlagReportOptions, ReviewFlagReportResponse, SdkIdentifier, SearchAPIResponse, SearchOptions, SegmentData, SegmentResponse, SegmentTargetsResponse, SegmentType, SendFileAPIResponse, SortParam, StreamChatOptions, SyncOptions, SyncResponse, TaskResponse, TaskStatus, TestPushDataInput, TestSNSDataInput, TestSQSDataInput, TokenOrProvider, TranslateResponse, UnBanUserOptions, UpdateChannelOptions, UpdateChannelResponse, UpdateCommandOptions, UpdateCommandResponse, UpdatedMessage, UpdateMessageAPIResponse, UpdateMessageOptions, UpdatePollAPIResponse, UpdatePollOptionAPIResponse, UpdateSegmentData, UpsertPushPreferencesResponse, UserCustomEvent, UserFilters, UserOptions, UserResponse, UserSort, VoteSort, QueryDraftsResponse, DraftFilters, DraftSort, Pager } from './types';
import { InsightMetrics } from './insights';
import { Thread } from './thread';
import { Moderation } from './moderation';
import { ThreadManager } from './thread_manager';
import { PollManager } from './poll_manager';
import { ChannelManager, ChannelManagerEventHandlerOverrides, ChannelManagerOptions } from './channel_manager';
export declare class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
private static _instance?;
_user?: OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>;
activeChannels: {
[key: string]: Channel<StreamChatGenerics>;
};
threads: ThreadManager<StreamChatGenerics>;
polls: PollManager<StreamChatGenerics>;
anonymous: boolean;
persistUserOnConnectionFailure?: boolean;
axiosInstance: AxiosInstance;
baseURL?: string;
browser: boolean;
cleaningIntervalRef?: NodeJS.Timeout;
clientID?: string;
configs: Configs<StreamChatGenerics>;
key: string;
listeners: Record<string, Array<(event: Event<StreamChatGenerics>) => void>>;
logger: Logger;
/**
* When network is recovered, we re-query the active channels on client. But in single query, you can recover
* only 30 channels. So its not guaranteed that all the channels in activeChannels object have updated state.
* Thus in UI sdks, state recovery is managed by components themselves, they don't rely on js client for this.
*
* `recoverStateOnReconnect` parameter can be used in such cases, to disable state recovery within js client.
* When false, user/consumer of this client will need to make sure all the channels present on UI by
* manually calling queryChannels endpoint.
*/
recoverStateOnReconnect?: boolean;
moderation: Moderation<StreamChatGenerics>;
mutedChannels: ChannelMute<StreamChatGenerics>[];
mutedUsers: Mute<StreamChatGenerics>[];
node: boolean;
options: StreamChatOptions;
secret?: string;
setUserPromise: ConnectAPIResponse<StreamChatGenerics> | null;
state: ClientState<StreamChatGenerics>;
tokenManager: TokenManager<StreamChatGenerics>;
user?: OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>;
userAgent?: string;
userID?: string;
wsBaseURL?: string;
wsConnection: StableWSConnection<StreamChatGenerics> | null;
wsFallback?: WSConnectionFallback<StreamChatGenerics>;
wsPromise: ConnectAPIResponse<StreamChatGenerics> | null;
consecutiveFailures: number;
insightMetrics: InsightMetrics;
defaultWSTimeoutWithFallback: number;
defaultWSTimeout: number;
sdkIdentifier?: SdkIdentifier;
deviceIdentifier?: DeviceIdentifier;
private nextRequestAbortController;
/**
* Initialize a client
*
* **Only use constructor for advanced usages. It is strongly advised to use `StreamChat.getInstance()` instead of `new StreamChat()` to reduce integration issues due to multiple WebSocket connections**
* @param {string} key - the api key
* @param {string} [secret] - the api secret
* @param {StreamChatOptions} [options] - additional options, here you can pass custom options to axios instance
* @param {boolean} [options.browser] - enforce the client to be in browser mode
* @param {boolean} [options.warmUp] - default to false, if true, client will open a connection as soon as possible to speed up following requests
* @param {Logger} [options.Logger] - custom logger
* @param {number} [options.timeout] - default to 3000
* @param {httpsAgent} [options.httpsAgent] - custom httpsAgent, in node it's default to https.agent()
* @example <caption>initialize the client in user mode</caption>
* new StreamChat('api_key')
* @example <caption>initialize the client in user mode with options</caption>
* new StreamChat('api_key', { warmUp:true, timeout:5000 })
* @example <caption>secret is optional and only used in server side mode</caption>
* new StreamChat('api_key', "secret", { httpsAgent: customAgent })
*/
constructor(key: string, options?: StreamChatOptions);
constructor(key: string, secret?: string, options?: StreamChatOptions);
/**
* Get a client instance
*
* This function always returns the same Client instance to avoid issues raised by multiple Client and WS connections
*
* **After the first call, the client configuration will not change if the key or options parameters change**
*
* @param {string} key - the api key
* @param {string} [secret] - the api secret
* @param {StreamChatOptions} [options] - additional options, here you can pass custom options to axios instance
* @param {boolean} [options.browser] - enforce the client to be in browser mode
* @param {boolean} [options.warmUp] - default to false, if true, client will open a connection as soon as possible to speed up following requests
* @param {Logger} [options.Logger] - custom logger
* @param {number} [options.timeout] - default to 3000
* @param {httpsAgent} [options.httpsAgent] - custom httpsAgent, in node it's default to https.agent()
* @example <caption>initialize the client in user mode</caption>
* StreamChat.getInstance('api_key')
* @example <caption>initialize the client in user mode with options</caption>
* StreamChat.getInstance('api_key', { timeout:5000 })
* @example <caption>secret is optional and only used in server side mode</caption>
* StreamChat.getInstance('api_key', "secret", { httpsAgent: customAgent })
*/
static getInstance<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(key: string, options?: StreamChatOptions): StreamChat<StreamChatGenerics>;
static getInstance<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(key: string, secret?: string, options?: StreamChatOptions): StreamChat<StreamChatGenerics>;
devToken(userID: string): string;
getAuthType(): "anonymous" | "jwt";
setBaseURL(baseURL: string): void;
_getConnectionID: () => string | undefined;
_hasConnectionID: () => boolean;
/**
* connectUser - Set the current user and open a WebSocket connection
*
* @param {OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>} user Data about this user. IE {name: "john"}
* @param {TokenOrProvider} userTokenOrProvider Token or provider
*
* @return {ConnectAPIResponse<StreamChatGenerics>} Returns a promise that resolves when the connection is setup
*/
connectUser: (user: OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>, userTokenOrProvider: TokenOrProvider) => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* @deprecated Please use connectUser() function instead. Its naming is more consistent with its functionality.
*
* setUser - Set the current user and open a WebSocket connection
*
* @param {OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>} user Data about this user. IE {name: "john"}
* @param {TokenOrProvider} userTokenOrProvider Token or provider
*
* @return {ConnectAPIResponse<StreamChatGenerics>} Returns a promise that resolves when the connection is setup
*/
setUser: (user: OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>, userTokenOrProvider: TokenOrProvider) => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
_setToken: (user: UserResponse<StreamChatGenerics>, userTokenOrProvider: TokenOrProvider) => Promise<void>;
_setUser(user: OwnUserResponse<StreamChatGenerics> | UserResponse<StreamChatGenerics>): void;
/**
* Disconnects the websocket connection, without removing the user set on client.
* client.closeConnection will not trigger default auto-retry mechanism for reconnection. You need
* to call client.openConnection to reconnect to websocket.
*
* This is mainly useful on mobile side. You can only receive push notifications
* if you don't have active websocket connection.
* So when your app goes to background, you can call `client.closeConnection`.
* And when app comes back to foreground, call `client.openConnection`.
*
* @param timeout Max number of ms, to wait for close event of websocket, before forcefully assuming succesful disconnection.
* https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
*/
closeConnection: (timeout?: number | undefined) => Promise<void>;
/**
* Creates an instance of ChannelManager.
*
* @internal
*
* @param eventHandlerOverrides - the overrides for event handlers to be used
* @param options - the options used for the channel manager
*/
createChannelManager: ({ eventHandlerOverrides, options, }: {
eventHandlerOverrides?: Partial<Record<import("./channel_manager").ChannelManagerEventHandlerNames, import("./channel_manager").EventHandlerOverrideType<StreamChatGenerics>>> | undefined;
options?: ChannelManagerOptions | undefined;
}) => ChannelManager<StreamChatGenerics>;
/**
* Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
*/
openConnection: () => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* @deprecated Please use client.openConnction instead.
* @private
*
* Creates a new websocket connection with current user.
*/
_setupConnection: () => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* updateAppSettings - updates application settings
*
* @param {AppSettings} options App settings.
* IE: {
'apn_config': {
'auth_type': 'token',
'auth_key": fs.readFileSync(
'./apn-push-auth-key.p8',
'utf-8',
),
'key_id': 'keyid',
'team_id': 'teamid',
'notification_template": 'notification handlebars template',
'bundle_id': 'com.apple.your.app',
'development': true
},
'firebase_config': {
'server_key': 'server key from fcm',
'notification_template': 'notification handlebars template',
'data_template': 'data handlebars template',
'apn_template': 'apn notification handlebars template under v2'
},
'webhook_url': 'https://acme.com/my/awesome/webhook/'
}
*/
updateAppSettings(options: AppSettings): Promise<APIResponse>;
_normalizeDate: (before: Date | string | null) => string | null;
/**
* Revokes all tokens on application level issued before given time
*/
revokeTokens(before: Date | string | null): Promise<APIResponse>;
/**
* Revokes token for a user issued before given time
*/
revokeUserToken(userID: string, before?: Date | string | null): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* Revokes tokens for a list of users issued before given time
*/
revokeUsersToken(userIDs: string[], before?: Date | string | null): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* getAppSettings - retrieves application settings
*/
getAppSettings(): Promise<AppSettingsAPIResponse<StreamChatGenerics>>;
/**
* testPushSettings - Tests the push settings for a user with a random chat message and the configured push templates
*
* @param {string} userID User ID. If user has no devices, it will error
* @param {TestPushDataInput} [data] Overrides for push templates/message used
* IE: {
messageID: 'id-of-message', // will error if message does not exist
apnTemplate: '{}', // if app doesn't have apn configured it will error
firebaseTemplate: '{}', // if app doesn't have firebase configured it will error
firebaseDataTemplate: '{}', // if app doesn't have firebase configured it will error
skipDevices: true, // skip config/device checks and sending to real devices
pushProviderName: 'staging' // one of your configured push providers
pushProviderType: 'apn' // one of supported provider types
}
*/
testPushSettings(userID: string, data?: TestPushDataInput): Promise<CheckPushResponse>;
/**
* testSQSSettings - Tests that the given or configured SQS configuration is valid
*
* @param {TestSQSDataInput} [data] Overrides SQS settings for testing if needed
* IE: {
sqs_key: 'auth_key',
sqs_secret: 'auth_secret',
sqs_url: 'url_to_queue',
}
*/
testSQSSettings(data?: TestSQSDataInput): Promise<CheckSQSResponse>;
/**
* testSNSSettings - Tests that the given or configured SNS configuration is valid
*
* @param {TestSNSDataInput} [data] Overrides SNS settings for testing if needed
* IE: {
sns_key: 'auth_key',
sns_secret: 'auth_secret',
sns_topic_arn: 'topic_to_publish_to',
}
*/
testSNSSettings(data?: TestSNSDataInput): Promise<CheckSNSResponse>;
/**
* Disconnects the websocket and removes the user from client.
*
* @param timeout Max number of ms, to wait for close event of websocket, before forcefully assuming successful disconnection.
* https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
*/
disconnectUser: (timeout?: number | undefined) => Promise<void>;
/**
*
* @deprecated Please use client.disconnectUser instead.
*
* Disconnects the websocket and removes the user from client.
*/
disconnect: (timeout?: number | undefined) => Promise<void>;
/**
* connectAnonymousUser - Set an anonymous user and open a WebSocket connection
*/
connectAnonymousUser: () => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* @deprecated Please use connectAnonymousUser. Its naming is more consistent with its functionality.
*/
setAnonymousUser: () => Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* setGuestUser - Setup a temporary guest user
*
* @param {UserResponse<StreamChatGenerics>} user Data about this user. IE {name: "john"}
*
* @return {ConnectAPIResponse<StreamChatGenerics>} Returns a promise that resolves when the connection is setup
*/
setGuestUser(user: UserResponse<StreamChatGenerics>): Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* createToken - Creates a token to authenticate this user. This function is used server side.
* The resulting token should be passed to the client side when the users registers or logs in.
*
* @param {string} userID The User ID
* @param {number} [exp] The expiration time for the token expressed in the number of seconds since the epoch
*
* @return {string} Returns a token
*/
createToken(userID: string, exp?: number, iat?: number): string;
/**
* on - Listen to events on all channels and users your watching
*
* client.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
* or
* client.on(event => {console.log(event.type)})
*
* @param {EventHandler<StreamChatGenerics> | string} callbackOrString The event type to listen for (optional)
* @param {EventHandler<StreamChatGenerics>} [callbackOrNothing] The callback to call
*
* @return {{ unsubscribe: () => void }} Description
*/
on(callback: EventHandler<StreamChatGenerics>): {
unsubscribe: () => void;
};
on(eventType: string, callback: EventHandler<StreamChatGenerics>): {
unsubscribe: () => void;
};
/**
* off - Remove the event handler
*
*/
off(callback: EventHandler<StreamChatGenerics>): void;
off(eventType: string, callback: EventHandler<StreamChatGenerics>): void;
_logApiRequest(type: string, url: string, data: unknown, config: AxiosRequestConfig & {
config?: AxiosRequestConfig & {
maxBodyLength?: number;
};
}): void;
_logApiResponse<T>(type: string, url: string, response: AxiosResponse<T>): void;
_logApiError(type: string, url: string, error: unknown): void;
doAxiosRequest: <T>(type: string, url: string, data?: unknown, options?: AxiosRequestConfig & {
config?: AxiosRequestConfig & {
maxBodyLength?: number;
};
}) => Promise<T>;
get<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
put<T>(url: string, data?: unknown): Promise<T>;
post<T>(url: string, data?: unknown): Promise<T>;
patch<T>(url: string, data?: unknown): Promise<T>;
delete<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
sendFile(url: string, uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse<StreamChatGenerics>): Promise<SendFileAPIResponse>;
errorFromResponse(response: AxiosResponse<APIErrorResponse>): ErrorFromResponse<APIErrorResponse>;
handleResponse<T>(response: AxiosResponse<T>): T;
dispatchEvent: (event: Event<StreamChatGenerics>) => void;
handleEvent: (messageEvent: WebSocket.MessageEvent) => void;
/**
* Updates the members, watchers and read references of the currently active channels that contain this user
*
* @param {UserResponse<StreamChatGenerics>} user
*/
_updateMemberWatcherReferences: (user: UserResponse<StreamChatGenerics>) => void;
/**
* @deprecated Please _updateMemberWatcherReferences instead.
* @private
*/
_updateUserReferences: (user: UserResponse<StreamChatGenerics>) => void;
/**
* @private
*
* Updates the messages from the currently active channels that contain this user,
* with updated user object.
*
* @param {UserResponse<StreamChatGenerics>} user
*/
_updateUserMessageReferences: (user: UserResponse<StreamChatGenerics>) => void;
/**
* @private
*
* Deletes the messages from the currently active channels that contain this user
*
* If hardDelete is true, all the content of message will be stripped down.
* Otherwise, only 'message.type' will be set as 'deleted'.
*
* @param {UserResponse<StreamChatGenerics>} user
* @param {boolean} hardDelete
*/
_deleteUserMessageReference: (user: UserResponse<StreamChatGenerics>, hardDelete?: boolean) => void;
/**
* @private
*
* Handle following user related events:
* - user.presence.changed
* - user.updated
* - user.deleted
*
* @param {Event} event
*/
_handleUserEvent: (event: Event<StreamChatGenerics>) => void;
_handleClientEvent(event: Event<StreamChatGenerics>): (() => void)[];
_muteStatus(cid: string): {
muted: boolean;
createdAt: Date;
expiresAt: Date | null;
} | {
muted: boolean;
createdAt: null;
expiresAt: null;
};
_callClientListeners: (event: Event<StreamChatGenerics>) => void;
recoverState: () => Promise<void>;
/**
* @private
*/
connect(): Promise<void | import("./types").ConnectionOpen<StreamChatGenerics>>;
/**
* Check the connectivity with server for warmup purpose.
*
* @private
*/
_sayHi(): void;
/**
* queryUsers - Query users and watch user presence
*
* @param {UserFilters<StreamChatGenerics>} filterConditions MongoDB style filter conditions
* @param {UserSort<StreamChatGenerics>} sort Sort options, for instance [{last_active: -1}].
* When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_active: -1}, {created_at: 1}]
* @param {UserOptions} options Option object, {presence: true}
*
* @return {Promise<{ users: Array<UserResponse<StreamChatGenerics>> }>} User Query Response
*/
queryUsers(filterConditions: UserFilters<StreamChatGenerics>, sort?: UserSort<StreamChatGenerics>, options?: UserOptions): Promise<APIResponse & {
users: Array<UserResponse<StreamChatGenerics>>;
}>;
/**
* queryBannedUsers - Query user bans
*
* @param {BannedUsersFilters} filterConditions MongoDB style filter conditions
* @param {BannedUsersSort} sort Sort options [{created_at: 1}].
* @param {BannedUsersPaginationOptions} options Option object, {limit: 10, offset:0, exclude_expired_bans: true}
*
* @return {Promise<BannedUsersResponse<StreamChatGenerics>>} Ban Query Response
*/
queryBannedUsers(filterConditions?: BannedUsersFilters, sort?: BannedUsersSort, options?: BannedUsersPaginationOptions): Promise<BannedUsersResponse<StreamChatGenerics>>;
/**
* queryMessageFlags - Query message flags
*
* @param {MessageFlagsFilters} filterConditions MongoDB style filter conditions
* @param {MessageFlagsPaginationOptions} options Option object, {limit: 10, offset:0}
*
* @return {Promise<MessageFlagsResponse<StreamChatGenerics>>} Message Flags Response
*/
queryMessageFlags(filterConditions?: MessageFlagsFilters, options?: MessageFlagsPaginationOptions): Promise<MessageFlagsResponse<StreamChatGenerics>>;
/**
* queryChannels - Query channels
*
* @param {ChannelFilters<StreamChatGenerics>} filterConditions object MongoDB style filters
* @param {ChannelSort<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 [{last_updated: -1}, {created_at: 1}]
* @param {ChannelOptions} [options] Options object
* @param {ChannelStateOptions} [stateOptions] State options object. These options will only be used for state management and won't be sent in the request.
* - stateOptions.skipInitialization - Skips the initialization of the state for the channels matching the ids in the list.
*
* @return {Promise<{ channels: Array<ChannelAPIResponse<AStreamChatGenerics>>}> } search channels response
*/
queryChannels(filterConditions: ChannelFilters<StreamChatGenerics>, sort?: ChannelSort<StreamChatGenerics>, options?: ChannelOptions, stateOptions?: ChannelStateOptions): Promise<Channel<StreamChatGenerics>[]>;
/**
* queryReactions - Query reactions
*
* @param {ReactionFilters<StreamChatGenerics>} filter object MongoDB style filters
* @param {ReactionSort<StreamChatGenerics>} [sort] Sort options, for instance {created_at: -1}.
* @param {QueryReactionsOptions} [options] Pagination object
*
* @return {Promise<{ QueryReactionsAPIResponse } search channels response
*/
queryReactions(messageID: string, filter: ReactionFilters<StreamChatGenerics>, sort?: ReactionSort<StreamChatGenerics>, options?: QueryReactionsOptions): Promise<QueryReactionsAPIResponse<StreamChatGenerics>>;
hydrateActiveChannels(channelsFromApi?: ChannelAPIResponse<StreamChatGenerics>[], stateOptions?: ChannelStateOptions, queryChannelsOptions?: ChannelOptions): Channel<StreamChatGenerics>[];
/**
* search - Query messages
*
* @param {ChannelFilters<StreamChatGenerics>} filterConditions MongoDB style filter conditions
* @param {MessageFilters<StreamChatGenerics> | string} query search query or object MongoDB style filters
* @param {SearchOptions<StreamChatGenerics>} [options] Option object, {user_id: 'tommaso'}
*
* @return {Promise<SearchAPIResponse<StreamChatGenerics>>} search messages response
*/
search(filterConditions: ChannelFilters<StreamChatGenerics>, query: string | MessageFilters<StreamChatGenerics>, options?: SearchOptions<StreamChatGenerics>): Promise<SearchAPIResponse<StreamChatGenerics>>;
/**
* setLocalDevice - Set the device info for the current client(device) that will be sent via WS connection automatically
*
* @param {BaseDeviceFields} device the device object
* @param {string} device.id device id
* @param {string} device.push_provider the push provider
*
*/
setLocalDevice(device: BaseDeviceFields): void;
/**
* addDevice - Adds a push device for a user.
*
* @param {string} id the device id
* @param {PushProvider} push_provider the push provider
* @param {string} [userID] the user id (defaults to current user)
* @param {string} [push_provider_name] user provided push provider name for multi bundle support
*
*/
addDevice(id: string, push_provider: PushProvider, userID?: string, push_provider_name?: string): Promise<APIResponse>;
/**
* getDevices - Returns the devices associated with a current user
*
* @param {string} [userID] User ID. Only works on serverside
*
* @return {Device<StreamChatGenerics>[]} Array of devices
*/
getDevices(userID?: string): Promise<APIResponse & {
devices?: Device<StreamChatGenerics>[] | undefined;
}>;
/**
* getUnreadCount - Returns unread counts for a single user
*
* @param {string} [userID] User ID.
*
* @return {<GetUnreadCountAPIResponse>}
*/
getUnreadCount(userID?: string): Promise<GetUnreadCountAPIResponse>;
/**
* getUnreadCountBatch - Returns unread counts for multiple users at once. Only works server side.
*
* @param {string[]} [userIDs] List of user IDs to fetch unread counts for.
*
* @return {<GetUnreadCountBatchAPIResponse>}
*/
getUnreadCountBatch(userIDs: string[]): Promise<GetUnreadCountBatchAPIResponse>;
/**
* setPushPreferences - Applies the list of push preferences.
*
* @param {PushPreference[]} A list of push preferences.
*
* @return {<UpsertPushPreferencesResponse>}
*/
setPushPreferences(preferences: PushPreference[]): Promise<UpsertPushPreferencesResponse>;
/**
* removeDevice - Removes the device with the given id. Clientside users can only delete their own devices
*
* @param {string} id The device id
* @param {string} [userID] The user id. Only specify this for serverside requests
*
*/
removeDevice(id: string, userID?: string): Promise<APIResponse>;
/**
* getRateLimits - Returns the rate limits quota and usage for the current app, possibly filter for a specific platform and/or endpoints.
* Only available server-side.
*
* @param {object} [params] The params for the call. If none of the params are set, all limits for all platforms are returned.
* @returns {Promise<GetRateLimitsResponse>}
*/
getRateLimits(params?: {
android?: boolean;
endpoints?: EndpointName[];
ios?: boolean;
serverSide?: boolean;
web?: boolean;
}): Promise<GetRateLimitsResponse>;
_addChannelConfig({ cid, config }: ChannelResponse<StreamChatGenerics>): void;
/**
* channel - Returns a new channel with the given type, id and custom data
*
* If you want to create a unique conversation between 2 or more users; you can leave out the ID parameter and provide the list of members.
* Make sure to await channel.create() or channel.watch() before accessing channel functions:
* ie. channel = client.channel("messaging", {members: ["tommaso", "thierry"]})
* await channel.create() to assign an ID to channel
*
* @param {string} channelType The channel type
* @param {string | ChannelData<StreamChatGenerics> | null} [channelIDOrCustom] The channel ID, you can leave this out if you want to create a conversation channel
* @param {object} [custom] Custom data to attach to the channel
*
* @return {channel} The channel object, initialize it using channel.watch()
*/
channel(channelType: string, channelID?: string | null, custom?: ChannelData<StreamChatGenerics>): Channel<StreamChatGenerics>;
channel(channelType: string, custom?: ChannelData<StreamChatGenerics>): Channel<StreamChatGenerics>;
/**
* It's a helper method for `client.channel()` method, used to create unique conversation or
* channel based on member list instead of id.
*
* If the channel already exists in `activeChannels` list, then we simply return it, since that
* means the same channel was already requested or created.
*
* Otherwise we create a new instance of Channel class and return it.
*
* @private
*
* @param {string} channelType The channel type
* @param {object} [custom] Custom data to attach to the channel
*
* @return {channel} The channel object, initialize it using channel.watch()
*/
getChannelByMembers: (channelType: string, custom: ChannelData<StreamChatGenerics>) => Channel<StreamChatGenerics>;
/**
* Its a helper method for `client.channel()` method, used to channel given the id of channel.
*
* If the channel already exists in `activeChannels` list, then we simply return it, since that
* means the same channel was already requested or created.
*
* Otherwise we create a new instance of Channel class and return it.
*
* @private
*
* @param {string} channelType The channel type
* @param {string} [channelID] The channel ID
* @param {object} [custom] Custom data to attach to the channel
*
* @return {channel} The channel object, initialize it using channel.watch()
*/
getChannelById: (channelType: string, channelID: string, custom: ChannelData<StreamChatGenerics>) => Channel<StreamChatGenerics>;
/**
* partialUpdateUser - Update the given user object
*
* @param {PartialUserUpdate<StreamChatGenerics>} partialUserObject which should contain id and any of "set" or "unset" params;
* example: {id: "user1", set:{field: value}, unset:["field2"]}
*
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>} list of updated users
*/
partialUpdateUser(partialUserObject: PartialUserUpdate<StreamChatGenerics>): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* upsertUsers - Batch upsert the list of users
*
* @param {UserResponse<StreamChatGenerics>[]} users list of users
*
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>}
*/
upsertUsers(users: UserResponse<StreamChatGenerics>[]): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* @deprecated Please use upsertUsers() function instead.
*
* updateUsers - Batch update the list of users
*
* @param {UserResponse<StreamChatGenerics>[]} users list of users
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>}
*/
updateUsers: (users: UserResponse<StreamChatGenerics>[]) => Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* upsertUser - Update or Create the given user object
*
* @param {UserResponse<StreamChatGenerics>} userObject user object, the only required field is the user id. IE {id: "myuser"} is valid
*
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>}
*/
upsertUser(userObject: UserResponse<StreamChatGenerics>): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* @deprecated Please use upsertUser() function instead.
*
* updateUser - Update or Create the given user object
*
* @param {UserResponse<StreamChatGenerics>} userObject user object, the only required field is the user id. IE {id: "myuser"} is valid
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>}
*/
updateUser: (userObject: UserResponse<StreamChatGenerics>) => Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
/**
* partialUpdateUsers - Batch partial update of users
*
* @param {PartialUserUpdate<StreamChatGenerics>[]} users list of partial update requests
*
* @return {Promise<{ users: { [key: string]: UserResponse<StreamChatGenerics> } }>}
*/
partialUpdateUsers(users: PartialUserUpdate<StreamChatGenerics>[]): Promise<APIResponse & {
users: {
[key: string]: UserResponse<StreamChatGenerics>;
};
}>;
deleteUser(userID: string, params?: {
delete_conversation_channels?: boolean;
hard_delete?: boolean;
mark_messages_deleted?: boolean;
}): Promise<APIResponse & {
user: UserResponse<StreamChatGenerics>;
} & {
task_id?: string | undefined;
}>;
/**
* restoreUsers - Restore soft deleted users
*
* @param {string[]} user_ids which users to restore
*
* @return {APIResponse} An API response
*/
restoreUsers(user_ids: string[]): Promise<APIResponse>;
/**
* reactivateUser - Reactivate one user
*
* @param {string} userID which user to reactivate
* @param {ReactivateUserOptions} [options]
*
* @return {UserResponse} Reactivated user
*/
reactivateUser(userID: string, options?: ReactivateUserOptions): Promise<APIResponse & {
user: UserResponse<StreamChatGenerics>;
}>;
/**
* reactivateUsers - Reactivate many users asynchronously
*
* @param {string[]} user_ids which users to reactivate
* @param {ReactivateUsersOptions} [options]
*
* @return {TaskResponse} A task ID
*/
reactivateUsers(user_ids: string[], options?: ReactivateUsersOptions): Promise<APIResponse & TaskResponse>;
/**
* deactivateUser - Deactivate one user
*
* @param {string} userID which user to deactivate
* @param {DeactivateUsersOptions} [options]
*
* @return {UserResponse} Deactivated user
*/
deactivateUser(userID: string, options?: DeactivateUsersOptions): Promise<APIResponse & {
user: UserResponse<StreamChatGenerics>;
}>;
/**
* deactivateUsers - Deactivate many users asynchronously
*
* @param {string[]} user_ids which users to deactivate
* @param {DeactivateUsersOptions} [options]
*
* @return {TaskResponse} A task ID
*/
deactivateUsers(user_ids: string[], options?: DeactivateUsersOptions): Promise<APIResponse & TaskResponse>;
exportUser(userID: string, options?: Record<string, string>): Promise<APIResponse & {
messages: MessageResponse<StreamChatGenerics>[];
reactions: ReactionResponse<StreamChatGenerics>[];
user: UserResponse<StreamChatGenerics>;
}>;
/** banUser - bans a user from all channels
*
* @param {string} targetUserID
* @param {BanUserOptions<StreamChatGenerics>} [options]
* @returns {Promise<APIResponse>}
*/
banUser(targetUserID: string, options?: BanUserOptions<StreamChatGenerics>): Promise<APIResponse>;
/** unbanUser - revoke global ban for a user
*
* @param {string} targetUserID
* @param {UnBanUserOptions} [options]
* @returns {Promise<APIResponse>}
*/
unbanUser(targetUserID: string, options?: UnBanUserOptions): Promise<APIResponse>;
/** shadowBan - shadow bans a user from all channels
*
* @param {string} targetUserID
* @param {BanUserOptions<StreamChatGenerics>} [options]
* @returns {Promise<APIResponse>}
*/
shadowBan(targetUserID: string, options?: BanUserOptions<StreamChatGenerics>): Promise<APIResponse>;
/** removeShadowBan - revoke global shadow ban for a user
*
* @param {string} targetUserID
* @param {UnBanUserOptions} [options]
* @returns {Promise<APIResponse>}
*/
removeShadowBan(targetUserID: string, options?: UnBanUserOptions): Promise<APIResponse>;
blockUser(blockedUserID: string, user_id?: string): Promise<BlockUserAPIResponse>;
getBlockedUsers(user_id?: string): Promise<GetBlockedUsersAPIResponse>;
unBlockUser(blockedUserID: string, userID?: string): Promise<APIResponse>;
/** muteUser - mutes a user
*
* @param {string} targetID
* @param {string} [userID] Only used with serverside auth
* @param {MuteUserOptions<StreamChatGenerics>} [options]
* @returns {Promise<MuteUserResponse<StreamChatGenerics>>}
*/
muteUser(targetID: string, userID?: string, options?: MuteUserOptions<StreamChatGenerics>): Promise<MuteUserResponse<StreamChatGenerics>>;
/** unmuteUser - unmutes a user
*
* @param {string} targetID
* @param {string} [currentUserID] Only used with serverside auth
* @returns {Promise<APIResponse>}
*/
unmuteUser(targetID: string, currentUserID?: string): Promise<APIResponse>;
/** userMuteStatus - check if a user is muted or not, can be used after connectUser() is called
*
* @param {string} targetID
* @returns {boolean}
*/
userMuteStatus(targetID: string): boolean;
/**
* flagMessage - flag a message
* @param {string} targetMessageID
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @returns {Promise<APIResponse>}
*/
flagMessage(targetMessageID: string, options?: {
reason?: string;
user_id?: string;
}): Promise<FlagMessageResponse<StreamChatGenerics>>;
/**
* flagUser - flag a user
* @param {string} targetID
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @returns {Promise<APIResponse>}
*/
flagUser(targetID: string, options?: {
reason?: string;
user_id?: string;
}): Promise<FlagUserResponse<StreamChatGenerics>>;
/**
* unflagMessage - unflag a message
* @param {string} targetMessageID
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @returns {Promise<APIResponse>}
*/
unflagMessage(targetMessageID: string, options?: {
user_id?: string;
}): Promise<FlagMessageResponse<StreamChatGenerics>>;
/**
* unflagUser - unflag a user
* @param {string} targetID
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @returns {Promise<APIResponse>}
*/
unflagUser(targetID: string, options?: {
user_id?: string;
}): Promise<FlagUserResponse<StreamChatGenerics>>;
/**
* getCallToken - retrieves the auth token needed to join a call
*
* @param {string} callID
* @param {object} options
* @returns {Promise<GetCallTokenResponse>}
*/
getCallToken(callID: string, options?: {
user_id?: string;
}): Promise<GetCallTokenResponse>;
/**
* _queryFlags - Query flags.
*
* Note: Do not use this.
* It is present for internal usage only.
* This function can, and will, break and/or be removed at any point in time.
*
* @private
* @param {FlagsFilters} filterConditions MongoDB style filter conditions
* @param {FlagsPaginationOptions} options Option object, {limit: 10, offset:0}
*
* @return {Promise<FlagsResponse<StreamChatGenerics>>} Flags Response
*/
_queryFlags(filterConditions?: FlagsFilters, options?: FlagsPaginationOptions): Promise<FlagsResponse<StreamChatGenerics>>;
/**
* _queryFlagReports - Query flag reports.
*
* Note: Do not use this.
* It is present for internal usage only.
* This function can, and will, break and/or be removed at any point in time.
*
* @private
* @param {FlagReportsFilters} filterConditions MongoDB style filter conditions
* @param {FlagReportsPaginationOptions} options Option object, {limit: 10, offset:0}
*
* @return {Promise<FlagReportsResponse<StreamChatGenerics>>} Flag Reports Response
*/
_queryFlagReports(filterConditions?: FlagReportsFilters, options?: FlagReportsPaginationOptions): Promise<FlagReportsResponse<StreamChatGenerics>>;
/**
* _reviewFlagReport - review flag report
*
* Note: Do not use this.
* It is present for internal usage only.
* This function can, and will, break and/or be removed at any point in time.
*
* @private
* @param {string} [id] flag report to review
* @param {string} [reviewResult] flag report review result
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @param {string} [options.review_details] custom information about review result
* @returns {Promise<ReviewFlagReportResponse>>}
*/
_reviewFlagReport(id: string, reviewResult: string, options?: ReviewFlagReportOptions): Promise<ReviewFlagReportResponse<StreamChatGenerics>>;
/**
* unblockMessage - unblocks message blocked by automod
*
*
* @param {string} targetMessageID
* @param {string} [options.user_id] currentUserID, only used with serverside auth
* @returns {Promise<APIResponse>}
*/
unblockMessage(targetMessageID: string, options?: {
user_id?: string;
}): Promise<APIResponse>;
_unblockMessage: (targetMessageID: string, options?: {
user_id?: string;
}) => Promise<APIResponse>;
/**
* @deprecated use markChannelsRead instead
*
* markAllRead - marks all channels for this user as read
* @param {MarkAllReadOptions<StreamChatGenerics>} [data]
*
* @return {Promise<APIResponse>}
*/
markAllRead: (data?: MarkChannelsReadOptions<StreamChatGenerics>) => Promise<void>;
/**
* markChannelsRead - marks channels read -
* it accepts a map of cid:messageid pairs, if messageid is empty, the whole channel will be marked as read
*
* @param {MarkChannelsReadOptions <StreamChatGenerics>} [data]
*
* @return {Promise<APIResponse>}
*/
markChannelsRead(data?: MarkChannelsReadOptions<StreamChatGenerics>): Promise<void>;
createCommand(data: CreateCommandOptions<StreamChatGenerics>): Promise<CreateCommandResponse<StreamChatGenerics>>;
getCommand(name: string): Promise<GetCommandResponse<StreamChatGenerics>>;
updateCommand(name: string, data: UpdateCommandOptions<StreamChatGenerics>): Promise<UpdateCommandResponse<StreamChatGenerics>>;
deleteCommand(name: string): Promise<DeleteCommandResponse<StreamChatGenerics>>;
listCommands(): Promise<ListCommandsResponse<StreamChatGenerics>>;
createChannelType(data: CreateChannelOptions<StreamChatGenerics>): Promise<CreateChannelResponse<StreamChatGenerics>>;
getChannelType(channelType: string): Promise<GetChannelTypeResponse<StreamChatGenerics>>;
updateChannelType(channelType: string, data: UpdateChannelOptions<StreamChatGenerics>): Promise<UpdateChannelResponse<StreamChatGenerics>>;
deleteChannelType(channelType: string): Promise<APIResponse>;
listChannelTypes(): Promise<ListChannelResponse<StreamChatGenerics>>;
/**
* translateMessage - adds the translation to the message
*
* @param {string} messageId
* @param {string} language
*
* @return {MessageResponse<StreamChatGenerics>} Response that includes the message
*/
translateMessage(messageId: string, language: string): Promise<APIResponse & StreamChatGenerics["messageType"] & {
id: string;
attachments?: import("./types").Attachment<StreamChatGenerics>[] | undefined;
html?: string | undefined;
mml?: string | undefined;
parent_id?: string | undefined;
pin_expires?: string | null | undefined;
pinned?: boolean | undefined;
pinned_at?: string | null | undefined;
poll_id?: string | undefined;
quoted_message_id?: string | undefined;
restricted_visibility?: string[] | undefined;
show_in_channel?: boolean | undefined;
silent?: boolean | undefined;
text?: string | undefined;
user?: UserResponse<StreamChatGenerics> | null | undefined;
user_id?: string | undefined;
} & {
type: import("./types").MessageLabel;
args?: string | undefined;
before_message_send_failed?: boolean | undefined;
channel?: ChannelResponse<StreamChatGenerics> | undefined;
cid?: string | undefined;
command?: string | undefined;
command_info?: {
name?: string | undefined;
} | undefined;
created_at?: string | undefined;
deleted_at?: string | undefined;
deleted_reply_count?: number | undefined;
i18n?: (import("./types").RequireAtLeastOne<Record<"_text" | "so_text" | "hr_text" | "th_text" | "tr_text" | "af_text" | "am_text" | "ar_text" | "az_text" | "bg_text" | "bn_text" | "bs_text" | "cs_text" | "da_text" | "de_text" | "el_text" | "en_text" | "es_text" | "es-MX_text" | "et_text" | "fa_text" | "fa-AF_text" | "fi_text" | "fr_text" | "fr-CA_text" | "ha_text" | "he_text" | "hi_text" | "hu_text" | "id_text" | "it_text" | "ja_text" | "ka_text" | "ko_text" | "lt_text" | "lv_text" | "ms_text" | "nl_text" | "no_text" | "pl_text" | "ps_text" | "pt_text" | "ro_text" | "ru_text" | "sk_text" | "sl_text" | "sq_text" | "sr_text" | "sv_text" | "sw_text" | "ta_text" | "tl_text" | "uk_text" | "ur_text" | "vi_text" | "zh_text" | "zh-TW_text", string>> & {
language: import("./types").TranslationLanguages;
}) | undefined;
latest_reactions?: ReactionResponse<StreamChatGenerics>[] | undefined;
me