stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/messageOperations/MessageOperations.d.ts

@@ -0,0 +1,17 @@
+import type { MessageOperationsContext, OperationParams, OperationRequestFn } from './types';
+export declare class MessageOperations {
+    private ctx;
+    private policy;
+    private failedSendCache;
+    constructor(ctx: MessageOperationsContext);
+    private normalizeMessage;
+    private pruneExpiredFailedSendCache;
+    private cacheFailedSend;
+    private getCachedFailedSend;
+    private clearCachedFailedSend;
+    private run;
+    send(params: OperationParams<'send'>, requestFn?: OperationRequestFn<'send'>): Promise<void>;
+    retry(params: OperationParams<'retry'>, requestFn?: OperationRequestFn<'retry'>): Promise<void>;
+    update(params: OperationParams<'update'>, requestFn?: OperationRequestFn<'update'>): Promise<void>;
+    delete(params: OperationParams<'delete'>, requestFn?: OperationRequestFn<'delete'>): Promise<void>;
+}

package/dist/types/messageOperations/index.d.ts

@@ -0,0 +1,3 @@
+export { MessageOperations } from './MessageOperations';
+export { MessageOperationStatePolicy } from './MessageOperationStatePolicy';
+export type { MessageOperationsContext, MessageOperationsHandlers, OperationKind, OperationParams, OperationRequestFn, OperationResponse, } from './types';

package/dist/types/messageOperations/types.d.ts

@@ -0,0 +1,49 @@
+import type { DeleteMessageOptions, LocalMessage, MessageRequest, MessageResponse, SendMessageAPIResponse, SendMessageOptions, UpdateMessageAPIResponse, UpdateMessageOptions } from '../types';
+export type OperationKind = 'send' | 'retry' | 'update' | 'delete';
+export type MessageOperationSpec = {
+    send: {
+        options: SendMessageOptions;
+        requestResult: SendMessageAPIResponse;
+    };
+    retry: {
+        options: SendMessageOptions;
+        requestResult: SendMessageAPIResponse;
+    };
+    update: {
+        options: UpdateMessageOptions;
+        requestResult: UpdateMessageAPIResponse;
+    };
+    delete: {
+        options: DeleteMessageOptions;
+        requestResult: {
+            message: MessageResponse;
+        };
+    };
+};
+export type OperationParams<K extends OperationKind> = {
+    localMessage: LocalMessage;
+    options?: MessageOperationSpec[K]['options'];
+} & (K extends 'send' | 'retry' ? {
+    message?: MessageRequest;
+} : {});
+export type OperationResponse = {
+    message: MessageResponse;
+};
+export type OperationRequestFn<K extends OperationKind> = (params: OperationParams<K>) => Promise<OperationResponse>;
+export type MessageOperationsHandlers = {
+    delete?: OperationRequestFn<'delete'>;
+    send?: OperationRequestFn<'send'>;
+    retry?: OperationRequestFn<'retry'>;
+    update?: OperationRequestFn<'update'>;
+};
+export type MessageOperationsContext = {
+    ingest: (m: LocalMessage) => void;
+    get: (id: string) => LocalMessage | undefined;
+    normalizeOutgoingMessage?: (m: MessageRequest) => MessageRequest;
+    defaults: {
+        delete: (id: string, o?: DeleteMessageOptions) => Promise<OperationResponse>;
+        send: (m: MessageRequest, o?: SendMessageOptions) => Promise<OperationResponse>;
+        update: (m: LocalMessage, o?: UpdateMessageOptions) => Promise<OperationResponse>;
+    };
+    handlers: () => MessageOperationsHandlers;
+};

package/dist/types/moderation.d.ts

@@ -1,220 +1,38 @@
-import type { APIResponse, CheckResponse, CustomCheckFlag, CustomCheckResponse, GetConfigResponse, GetUserModerationReportOptions, GetUserModerationReportResponse, ModerationConfig, ModerationFlagOptions, ModerationMuteOptions, ModerationRule, ModerationRuleRequest, Pager, QueryConfigsResponse, QueryModerationConfigsFilters, QueryModerationConfigsSort, QueryModerationRulesFilters, QueryModerationRulesResponse, QueryModerationRulesSort, RequireAtLeastOne, ReviewQueueFilters, ReviewQueuePaginationOptions, ReviewQueueResponse, ReviewQueueSort, SubmitActionOptions, SubmitActionResponse, UnmuteUserResponse, UpsertConfigResponse, UpsertModerationRuleResponse } from './types';
+import type { ModerationFlagOptions, UnmuteUserResponse } from './types';
 import type { StreamChat } from './client';
+import { ModerationApi } from './gen/moderation/ModerationApi';
 export declare const MODERATION_ENTITY_TYPES: {
     user: string;
     message: string;
-    userprofile: string;
 };
-export declare class Moderation {
+export declare class Moderation extends ModerationApi {
     client: StreamChat;
     constructor(client: StreamChat);
     /**
-     * Flag a user
+     * Flags a user.
      *
-     * @param {string} flaggedUserID User ID to be flagged
-     * @param {string} reason Reason for flagging the user
-     * @param {Object} options Additional options for flagging the user
-     * @param {string} options.user_id (For server side usage) User ID of the user who is flagging the target user
-     * @param {Object} options.custom Additional data to be stored with the flag
-     * @returns
+     * @param flaggedUserId - User ID to be flagged.
+     * @param reason - Reason for flagging the user.
+     * @param options - Additional options for flagging the user (optional, defaults to `{}`).
+     * @param options.custom - Additional data to be stored with the flag (optional).
+     * @returns The flag response.
      */
-    flagUser(flaggedUserID: string, reason: string, options?: ModerationFlagOptions): Promise<{
-        item_id: string;
-    } & APIResponse>;
+    flagUser(flaggedUserId: string, reason: string, options?: ModerationFlagOptions): Promise<import("./types").StreamResponse<import(".").FlagItemResponse>>;
     /**
-     * Flag a message
+     * Flags a message.
      *
-     * @param {string} messageID Message ID to be flagged
-     * @param {string} reason Reason for flagging the message
-     * @param {Object} options Additional options for flagging the message
-     * @param {string} options.user_id (For server side usage) User ID of the user who is flagging the target message
-     * @param {Object} options.custom Additional data to be stored with the flag
-     * @returns
+     * @param messageId - MessageRequest ID to be flagged.
+     * @param reason - Reason for flagging the message.
+     * @param options - Additional options for flagging the message (optional, defaults to `{}`).
+     * @param options.custom - Additional data to be stored with the flag (optional).
+     * @returns The flag response.
      */
-    flagMessage(messageID: string, reason: string, options?: ModerationFlagOptions): Promise<{
-        item_id: string;
-    } & APIResponse>;
+    flagMessage(messageId: string, reason: string, options?: ModerationFlagOptions): Promise<import("./types").StreamResponse<import(".").FlagItemResponse>>;
     /**
-     * Flag a user
+     * Unmutes a user.
      *
-     * @param {string} entityType Entity type to be flagged
-     * @param {string} entityId Entity ID to be flagged
-     * @param {string} entityCreatorID User ID of the entity creator
-     * @param {string} reason Reason for flagging the entity
-     * @param {Object} options Additional options for flagging the entity
-     * @param {string} options.user_id (For server side usage) User ID of the user who is flagging the target entity
-     * @param {Object} options.moderation_payload Content to be flagged e.g., { texts: ['text1', 'text2'], images: ['image1', 'image2']}
-     * @param {Object} options.custom Additional data to be stored with the flag
-     * @returns
+     * @param targetId - User ID to be unmuted.
+     * @returns The unmute response.
      */
-    flag(entityType: string, entityId: string, entityCreatorID: string, reason: string, options?: ModerationFlagOptions): Promise<{
-        item_id: string;
-    } & APIResponse>;
-    /**
-     * Mute a user
-     * @param {string} targetID  User ID to be muted
-     * @param {Object} options Additional options for muting the user
-     * @param {string} options.user_id (For server side usage) User ID of the user who is muting the target user
-     * @param {number} options.timeout Timeout for the mute in minutes
-     * @returns
-     */
-    muteUser(targetID: string, options?: ModerationMuteOptions): Promise<APIResponse & {
-        mute?: import("./types").MuteResponse;
-        mutes?: Array<import("./types").Mute>;
-        own_user?: import("./types").OwnUserResponse;
-        non_existing_users?: string[];
-    }>;
-    /**
-     * Unmute a user
-     * @param {string} targetID  User ID to be unmuted
-     * @param {Object} options Additional options for unmuting the user
-     * @param {string} options.user_id (For server side usage) User ID of the user who is unmuting the target user
-     * @returns
-     */
-    unmuteUser(targetID: string, options: {
-        user_id?: string;
-    }): Promise<UnmuteUserResponse>;
-    /**
-     * Get moderation report for a user
-     * @param {string} userID User ID for which moderation report is to be fetched
-     * @param {Object} options Additional options for fetching the moderation report
-     * @param {boolean} options.create_user_if_not_exists Create user if not exists
-     * @param {boolean} options.include_user_blocks Include user blocks
-     * @param {boolean} options.include_user_mutes Include user mutes
-     */
-    getUserModerationReport(userID: string, options?: GetUserModerationReportOptions): Promise<GetUserModerationReportResponse>;
-    /**
-     * Query review queue
-     * @param {Object} filterConditions Filter conditions for querying review queue
-     * @param {Object} sort Sort conditions for querying review queue
-     * @param {Object} options Pagination options for querying review queue
-     */
-    queryReviewQueue(filterConditions?: ReviewQueueFilters, sort?: ReviewQueueSort, options?: ReviewQueuePaginationOptions): Promise<ReviewQueueResponse>;
-    /**
-     * Upsert moderation config
-     * @param {Object} config Moderation config to be upserted
-     */
-    upsertConfig(config: ModerationConfig): Promise<UpsertConfigResponse>;
-    /**
-     * Get moderation config
-     * @param {string} key Key for which moderation config is to be fetched
-     */
-    getConfig(key: string, data?: {
-        team?: string;
-    }): Promise<GetConfigResponse>;
-    deleteConfig(key: string, data?: {
-        team?: string;
-    }): Promise<APIResponse>;
-    /**
-     * Query moderation configs
-     * @param {Object} filterConditions Filter conditions for querying moderation configs
-     * @param {Object} sort Sort conditions for querying moderation configs
-     * @param {Object} options Additional options for querying moderation configs
-     */
-    queryConfigs(filterConditions: QueryModerationConfigsFilters, sort: QueryModerationConfigsSort, options?: Pager): Promise<QueryConfigsResponse>;
-    submitAction(actionType: string, itemID: string, options?: SubmitActionOptions): Promise<SubmitActionResponse>;
-    /**
-     *
-     * @param {string} entityType string Type of entity to be checked E.g., stream:user, stream:chat:v1:message, or any custom string
-     * @param {string} entityID string ID of the entity to be checked. This is mainly for tracking purposes
-     * @param {string} entityCreatorID string ID of the entity creator
-     * @param {object} moderationPayload object Content to be checked for moderation. E.g., { texts: ['text1', 'text2'], images: ['image1', 'image2']}
-     * @param {Array} moderationPayload.texts array Array of texts to be checked for moderation
-     * @param {Array} moderationPayload.images array Array of images to be checked for moderation
-     * @param {Array} moderationPayload.videos array Array of videos to be checked for moderation
-     * @param configKey
-     * @param options
-     * @returns
-     */
-    check(entityType: string, entityID: string, entityCreatorID: string, moderationPayload: {
-        custom?: Record<string, any>;
-        images?: string[];
-        texts?: string[];
-        videos?: string[];
-    }, configKey: string, options?: {
-        force_sync?: boolean;
-    }, testMode?: boolean): Promise<CheckResponse>;
-    /**
-     * Experimental: Check user profile
-     *
-     * Warning: This is an experimental feature and the API is subject to change.
-     *
-     * This function is used to check a user profile for moderation.
-     * This will not create any review queue items for the user profile.
-     * You can just use this to check whether to allow a certain user profile to be created or not.
-     *
-     * Example:
-     *
-     * ```ts
-     * const res = await client.moderation.checkUserProfile(userId, { username: "fuck_boy_001", image: "https://example.com/profile.jpg" });
-     * if (res.recommended_action === "remove") {
-     *   // Block the user profile from being created
-     * } else {
-     *   // Allow the user profile to be created
-     * }
-     * ```
-     *
-     * @param userId
-     * @param profile.username
-     * @param profile.image
-     * @returns
-     */
-    checkUserProfile(userId: string, profile: RequireAtLeastOne<{
-        image?: string;
-        username?: string;
-    }>): Promise<CheckResponse>;
-    /**
-     *
-     * @param {string} entityType string Type of entity to be checked E.g., stream:user, stream:chat:v1:message, or any custom string
-     * @param {string} entityID string ID of the entity to be checked. This is mainly for tracking purposes
-     * @param {string} entityCreatorID string ID of the entity creator
-     * @param {object} moderationPayload object Content to be checked for moderation. E.g., { texts: ['text1', 'text2'], images: ['image1', 'image2']}
-     * @param {Array} moderationPayload.texts array Array of texts to be checked for moderation
-     * @param {Array} moderationPayload.images array Array of images to be checked for moderation
-     * @param {Array} moderationPayload.videos array Array of videos to be checked for moderation
-     * @param {object} moderationPayload.custom object Additional custom data to attach to the moderation review queue item
-     * @param {Array<CustomCheckFlag>} flags Array of CustomCheckFlag to be passed to flag the entity
-     * @returns
-     */
-    addCustomFlags(entityType: string, entityID: string, entityCreatorID: string, moderationPayload: {
-        custom?: Record<string, any>;
-        images?: string[];
-        texts?: string[];
-        videos?: string[];
-    }, flags: CustomCheckFlag[]): Promise<CustomCheckResponse>;
-    /**
-     * Add custom flags to a message
-     * @param {string} messageID Message ID to be flagged
-     * @param {Array<CustomCheckFlag>} flags Array of CustomCheckFlag to be passed to flag the message
-     * @returns
-     */
-    addCustomMessageFlags(messageID: string, flags: CustomCheckFlag[]): Promise<CustomCheckResponse>;
-    /**
-     * Create or update a moderation rule
-     * @param {ModerationRuleRequest} rule Rule configuration to be upserted
-     * @returns
-     */
-    upsertModerationRule(rule: ModerationRuleRequest): Promise<UpsertModerationRuleResponse>;
-    /**
-     * Query moderation rules
-     * @param {QueryModerationRulesFilters} filterConditions Filter conditions for querying moderation rules
-     * @param {QueryModerationRulesSort} sort Sort conditions for querying moderation rules
-     * @param {Pager} options Pagination options for querying moderation rules
-     * @returns
-     */
-    queryModerationRules(filterConditions?: QueryModerationRulesFilters, sort?: QueryModerationRulesSort, options?: Pager): Promise<QueryModerationRulesResponse>;
-    /**
-     * Get a specific moderation rule by ID
-     * @param {string} id ID of the moderation rule to fetch
-     * @returns
-     */
-    getModerationRule(id: string): Promise<{
-        rule: ModerationRule;
-    }>;
-    /**
-     * Delete a moderation rule by ID
-     * @param {string} id ID of the moderation rule to delete
-     * @returns
-     */
-    deleteModerationRule(id: string): Promise<APIResponse>;
+    unmuteUser(targetId: string): Promise<UnmuteUserResponse>;
 }

package/dist/types/notifications/types.d.ts

@@ -28,7 +28,7 @@ export type Notification = {
     origin: NotificationOrigin;
     /** Array of action buttons for the notification */
     actions?: NotificationAction[];
-    /** The severity level of the notification. Defaults to undefined unless explicitly provided. */
+    /** The severity level of the notification (defaults to `undefined` unless explicitly provided). */
     severity?: NotificationSeverity;
     /**
      * Optional code that can be used to group the notifications of the same type, e.g. attachment-upload-blocked.
@@ -50,9 +50,9 @@ export type Notification = {
      *   'validation:attachment:size:exceeded'    // File size too large
      *   'validation:attachment:count:exceeded'   // Too many attachments
      *
-     *   Message related errors
-     *   'api:message:send:failed'          // Message send failed
-     *   'validation:message:content:empty' // Message content validation failed
+     *   MessageRequest related errors
+     *   'api:message:send:failed'          // MessageRequest send failed
+     *   'validation:message:content:empty' // MessageRequest content validation failed
      *
      *   Channel related errors
      *   'api:channel:join:failed'          // Channel join failed
@@ -92,11 +92,12 @@ export type NotificationOptions = Partial<Pick<Notification, 'type' | 'severity'
     duration?: number;
 };
 /**
- * State shape for the notification store
- * @deprcated use NotificationManagerState
+ * State shape for the notification store.
+ *
+ * @deprecated Use {@link NotificationManagerState} instead.
  */
 export type NotificationState = {
-    /** Array of current notification objects */
+    /** Array of current notification objects. */
     notifications: Notification[];
 };
 /** State shape for the notification store */