@grammyjs/chat-members/out/filters.d.ts

Chat member plugin for grammY

import type { ChatMember, ChatMemberAdministrator, ChatMemberBanned, ChatMemberLeft, ChatMemberMember, ChatMemberOwner, ChatMemberRestricted, Context, Filter } from "./deps.node.js";
/**
 * A member of the chat, with restrictions applied.
 */
export type ChatMemberRestrictedIn = ChatMemberRestricted & {
    is_member: true;
};
/**
 * Not a member of the chat, with restrictions applied.
 */
export type ChatMemberRestrictedOut = ChatMemberRestricted & {
    is_member: false;
};
/**
 * A member of the chat, with any role, possibly restricted.
 */
export type ChatMemberIn = ChatMemberAdministrator | ChatMemberOwner | ChatMemberRestrictedIn | ChatMemberMember;
/**
 * Not a member of the chat
 */
export type ChatMemberOut = ChatMemberBanned | ChatMemberLeft | ChatMemberRestrictedOut;
/**
 * A member of the chat, with any role, not restricted.
 */
export type ChatMemberFree = ChatMemberAdministrator | ChatMemberOwner | ChatMemberMember;
/**
 * An admin of the chat, either administrator or owner.
 */
export type ChatMemberAdmin = ChatMemberAdministrator | ChatMemberOwner;
/**
 * A regular (non-admin) user of the chat, possibly restricted.
 */
export type ChatMemberRegular = ChatMemberRestrictedIn | ChatMemberMember;
/**
 * Query type for chat member status.
 */
export type ChatMemberQuery = "in" | "out" | "free" | "admin" | "regular" | "restricted_in" | "restricted_out" | ChatMember["status"];
/**
 * Used to normalize queries to the simplest components.
 */
declare const chatMemberQueries: {
    readonly admin: ["administrator", "creator"];
    readonly administrator: ["administrator"];
    readonly creator: ["creator"];
    readonly free: ["administrator", "creator", "member"];
    readonly in: ["administrator", "creator", "member", "restricted_in"];
    readonly out: ["kicked", "left", "restricted_out"];
    readonly regular: ["member", "restricted_in"];
    readonly kicked: ["kicked"];
    readonly left: ["left"];
    readonly member: ["member"];
    readonly restricted: ["restricted"];
    readonly restricted_in: ["restricted_in"];
    readonly restricted_out: ["restricted_out"];
};
/**
 * Maps from the query to the corresponding type.
 */
type ChatMemberQueriesMap = {
    admin: ChatMemberAdmin;
    administrator: ChatMemberAdministrator;
    creator: ChatMemberOwner;
    free: ChatMemberFree;
    in: ChatMemberIn;
    out: ChatMemberOut;
    regular: ChatMemberRegular;
    kicked: ChatMemberBanned;
    left: ChatMemberLeft;
    member: ChatMemberMember;
    restricted: ChatMemberRestricted;
    restricted_in: ChatMemberRestrictedIn;
    restricted_out: ChatMemberRestrictedOut;
};
type MaybeArray<T> = T | T[];
type NormalizeChatMemberQuery<Q extends ChatMemberQuery> = (typeof chatMemberQueries)[Q][number];
export type FilteredChatMember<C extends ChatMember, Q extends ChatMemberQuery> = C & ChatMemberQueriesMap[NormalizeChatMemberQuery<Q>];
/**
 * Utility function to query the status of a chat member.
 *
 * Pass one of 'restricted_in', 'restricted_out', 'in', 'out', 'free', 'admin',
 * 'regular', or one of the default Telegram statuses ('administrator',
 * 'creator', 'kicked', 'left', 'member', 'restricted'), or an array of them.
 *
 * Returns true if the chat member matches the query.
 */
export declare function chatMemberIs<C extends ChatMember, Q extends ChatMemberQuery>(chatMember: C, query: MaybeArray<Q>): chatMember is FilteredChatMember<C, Q>;
/**
 * Filter context to only find updates of type 'my_chat_member' where the status
 * transitions from oldStatus to newStatus.
 *
 * Example:
 * ```typescript
 * // listen for updates where the bot enters a group/supergroup
 * bot.chatType(['group', 'supergroup']).filter(
 *  myChatMemberFilter('out', 'in'),
 *  (ctx) => {
 *    const { old_chat_member: oldChatMember, new_chat_member: newChatMember } =
 *      ctx.myChatMember;
 *    // ...
 *  },
 * );
 */
export declare function myChatMemberFilter<C extends Context, Q1 extends ChatMemberQuery, Q2 extends ChatMemberQuery>(oldStatus: MaybeArray<Q1>, newStatus: MaybeArray<Q2>): (ctx: C) => ctx is Filter<C, "my_chat_member"> & {
    myChatMember: {
        old_chat_member: FilteredChatMember<ChatMember, Q1>;
        new_chat_member: FilteredChatMember<ChatMember, Q2>;
    };
};
/**
 * Filter context to only find updates of type 'chat_member' where the status
 * transitions from oldStatus to newStatus.
 *
 * Example:
 * ```typescript
 * // listen for updates where a user leaves a channel
 * bot.chatType('channel').filter(
 *  chatMemberFilter('in', 'out'),
 *  (ctx) => {
 *    const { old_chat_member: oldChatMember, new_chat_member: newChatMember } =
 *      ctx.chatMember;
 *    // ...
 *  },
 * );
 * ```
 *
 * **Note**: To receive these updates the bot must be admin in the chat **and**
 * you must add 'chat_member' to the list of allowed updates.
 */
export declare function chatMemberFilter<C extends Context, Q1 extends ChatMemberQuery, Q2 extends ChatMemberQuery>(oldStatus: MaybeArray<Q1>, newStatus: MaybeArray<Q2>): (ctx: C) => ctx is Filter<C, "chat_member"> & {
    chatMember: {
        old_chat_member: FilteredChatMember<ChatMember, Q1>;
        new_chat_member: FilteredChatMember<ChatMember, Q2>;
    };
};
export {};