node-vk-api-bot/dist/index.d.ts

A library that helps you to create chat-bot for group or user

import Methods from './methods.js';
import { GroupUpdates } from './group-updates.js';
declare type AllMethods<T> = Methods.AllMethods<T>;
declare type BotType = 'group' | 'user';
declare type BotInit<T extends BotType> = ({
    token: string;
    type: T;
}) & (T extends 'group' ? {
    group_id: number;
} : {
    group_id?: number | null;
});
import { UserUpdates } from './user-updates.js';
declare type ResponseType<G extends BotType, T extends AllMethods<G>> = Methods.MethodResponse[T];
declare type ErrorType = {
    error_code: number;
    error_msg: string;
    request_params: Record<string, string>[];
};
declare type RawResponse<G extends BotType, T extends AllMethods<G>> = {
    response: ResponseType<G, T>;
    error?: never;
} | {
    response?: never;
    error: ErrorType;
};
declare type MethodParams<G extends BotType, T extends AllMethods<G>, P = Methods.MethodRequest[T]> = {
    method: T;
    overrideToken?: string;
} & (P extends null ? {
    params?: null;
} : {
    params: P;
});
declare type StaticMethodParams<G extends BotType, T extends AllMethods<G>> = {
    method: T;
    token: string;
    params: Methods.MethodRequest[T];
};
declare type MethodCallback<G extends BotType, T extends AllMethods<G>> = (data: MethodResponse<G, T>) => void;
declare type pollingOptions<T extends BotType> = {
    wait: number;
} & (T extends 'user' ? {
    mode: {
        attachment?: boolean;
        extraEvents?: boolean;
        returnPTS?: boolean;
        return$extraInEvent8?: boolean;
        returnRandomId?: boolean;
    } | number;
} : {
    wait: number;
});
declare class MethodResponse<G extends BotType, T extends AllMethods<G>> {
    response: Methods.MethodResponse[T] | null;
    error: ErrorType | null;
    constructor(data: RawResponse<G, T>);
    /**
     * Calls callback function if response state is not error
     * @returns reference to response so you can chain `ifError` and `ifResponse`
     * ```js
     * new Bot().method().then(data => data.ifError((e) => console.error(e)).ifResponse((r) => {}));
     * ```
     */
    ifResponse(cb: (data: Methods.MethodResponse[T]) => void): this;
    /**
     * Calls callback function if response state is error
     * @returns reference to response so you can chain `ifError` and `ifResponse`
     * ```js
     * new Bot().method().then(data => data.ifError((e) => console.error(e)).ifResponse((r) => {}));
     * ```
     */
    ifError(cb: (err: ErrorType) => void): this;
}
declare class Bot<T extends BotType> {
    #private;
    group_id: number | null;
    type: T;
    v: 5.131;
    constructor(options: BotInit<T>);
    /**
     * Add a listener to event
     *
     * If added a listener to `any` event, no one typed event is more returned
     *
     * If event type is `raw` (for user long poll) adding of listeners for not-`raw` version is ignored
     * @param event Event name
     * @param listener callback function
     * @returns reference to `this`
     */
    addEventListener<G extends T extends 'user' ? UserUpdates.UpdateTypes : GroupUpdates.UpdateTypes = T extends 'user' ? UserUpdates.UpdateTypes : GroupUpdates.UpdateTypes, E extends G | 'any' | 'any_raw' = 'any'>(event: E, listener: (update: (G extends UserUpdates.UpdateTypes ? E extends `raw_${string}` ? UserUpdates.Update<E> : UserUpdates.Update<E extends 'any' | 'any_raw' ? any : E> : GroupUpdates.Update<E extends 'any' | 'any_raw' ? any : E>)) => void): this;
    on: <G extends T extends "user" ? UserUpdates.UpdateTypes : GroupUpdates.UpdateTypes = T extends "user" ? UserUpdates.UpdateTypes : GroupUpdates.UpdateTypes, E extends G | "any" | "any_raw" = "any">(event: E, listener: (update: G extends UserUpdates.UpdateTypes ? E extends `raw_${string}` ? UserUpdates.Update<E> : UserUpdates.Update<E extends "any" | "any_raw" ? any : E> : GroupUpdates.Update<E extends "any" | "any_raw" ? any : E>) => void) => this;
    static method<G extends BotType, M extends AllMethods<G>>(options: StaticMethodParams<G, M>): Promise<MethodResponse<G, M>>;
    static method<G extends BotType, M extends AllMethods<G>>(options: StaticMethodParams<G, M>, cb?: MethodCallback<G, M>): void;
    method<M extends AllMethods<T>>(options: MethodParams<T, M>, cb: MethodCallback<T, M>): void;
    method<M extends AllMethods<T>>(options: MethodParams<T, M>): Promise<MethodResponse<T, M>>;
    startPolling(options?: pollingOptions<T>): Promise<void>;
    startPolling(options?: pollingOptions<T>, cb?: () => void): Promise<void>;
    startPolling(cb?: () => void): Promise<void>;
    /**
     * Stops current LongPoll request
     * @returns `true` if polling has been stopped otherwise `false`
     */
    stopPolling(cb?: () => void): boolean;
}
export { Methods, GroupUpdates, UserUpdates, };
export default Bot;