import type { Invoke, Execute, Update as Td$Update, setTdlibParameters as Td$setTdlibParameters } from 'tdlib-types' export type TDLibParameters = Omit export type TDLibConfiguration = { /** * The path to libtdjson. Defaults to `'tdjson.dll'` on Windows, * `'libtdjson.dylib'` on macOS, or `'libtdjson.so'` on a different OS. */ tdjson?: string, /** * The path to the directory with libtdjson. Defaults to `''`. Can be set to, * for example, `'/usr/local/lib'` or `__dirname` while keeping the `tdjson` * option unchanged. */ libdir?: string, /** * Set the verbosity level of TDLib. Defaults to `1`. From the TDLib * documentation: * - 0 corresponds to fatal errors, * - 1 corresponds to errors, * - 2 corresponds to warnings and debug warnings, * - 3 corresponds to informational, * - 4 corresponds to debug, * - 5 corresponds to verbose deubg, * - value greater than 5 and up to 1024 can be used to enable even more * logging. * * Another possible option is `'default'`, `tdl` then won't send any * verbosity level to TDLib. */ verbosityLevel?: number | 'default', /** * Advanced option. Use the old tdjson interface (`td_json_client_create`, * etc.) instead of the one that was added in TDLib v1.7.0 * (`td_create_client_id`, etc). Defaults to `false`. */ useOldTdjsonInterface?: boolean, /** * Advanced option. Configures the delay for the `receive` tdjson function. * Defaults to `10.0` seconds. */ receiveTimeout?: number, } /** * Configure options such as path to the tdjson library or the verbosity level. * Only options passed in the object are set; can be called none or multiple * times. The shared library will be loaded using `path.join(libdir, tdjson)` as * `filename`. Should be called before `createClient`, `execute`, `init`, etc. */ export function configure(cfg: TDLibConfiguration): void /** * Call a TDLib method synchronously. Can be used only with the methods * marked as "can be called synchronously" in the TDLib documentation. */ export const execute: Execute /** * The `td_set_log_message_callback` tdjson function, sets the callback that * will be called when a message is added to the internal TDLib log. Note that * setting a callback overrides the previous callback. Pass null to remove the * callback. */ export function setLogMessageCallback( maxVerbosityLevel: number, callback: null | ((verbosityLevel: number, message: string) => void) ): void /** Create a TDLib client. */ export function createClient(opts: ClientOptions): Client export interface Client { /** * Set up an update handler that will log you in to your Telegram account. The * promise resolves in case the account is successfully authenticated. By * default, this asks for the credentials in the console; that can be * overrided by passing the callbacks. If a function is passed as * `loginDetails`, it will not be called unless any of the handlers trigger. * `login` supports only a subset of available authentication methods. */ login(loginDetails?: LoginDetails | (() => LoginDetails)): Promise; /** * Log in as a bot. You can get the token from `@BotFather`. * If the client is already logged in as a user, it will not be relogged * as a bot. In case a function is passed instead of string, it will not be * called if you are already logged in. * This function is short for * ``` * client.login({ * type: 'bot', * getToken: retry => retry * ? Promise.reject(new Error('Invalid bot token')) * : Promise.resolve(typeof token === 'string' ? token : token()) * }) * ``` */ loginAsBot(token: string | (() => string | Promise)): Promise; /** * Call a TDLib method. Example: * ``` * const me = await client.invoke({ _: 'getMe' }) * console.log(`I am ${me.first_name}`) * ``` */ invoke: Invoke; /** * Attach an event listener. This function can be used to iterate through * updates. Possible events: `update`, `error`, `close`. * * The `error` event fires in case an exception is thrown in the `update` or * `close` handlers, an error occured during the initialization * `setTdlibParameters` phase (e.g. if some of the client options are * incorrect), or potentially in case of some internal tdl error. */ on: On; /** * Same as `client.on`, but attaches a one-time event listener instead. The * listener is removed after it is called. A single function cannot be reused * for both `on` and `once`. */ once: On; /** * Remove an event listener. Returns `true` if the listener has been * successfully removed, `false` otherwise. */ off: Off; /** Alias for `client.on`. */ addListener: On; /** Alias for `client.off`. */ removeListener: Off; /** * Iterate received updates using JavaScript async iterators. This is an * alternative to `client.on('update', ...)`, one can use either. Example: * ``` * for await (const update of client.iterUpdates()) { * if (update._ === 'updateOption' && update.name === 'my_id') { * console.log(`My ID is ${update.value.value}!`) * break * } * } * ``` */ iterUpdates(): AsyncIterableIterator; /** Alias for `tdl.execute`. */ execute: Execute; /** * Close the client. This sends `{ _: 'close' }` and waits for * `authorizationStateClosed`. * * There are also other methods to close the TDLib instance, namely * `client.invoke({ _: 'logOut' })` and `client.invoke({ _: 'destroy' })`. */ close(): Promise; /** * Get the TDLib version in the `major.minor.patch` format. Can throw an * exception if the version (the `updateOption` update) is not (yet) received. */ getVersion(): string; /** * Test whether the client is closed (that is, `authorizationStateClosed` has * been received, and the TDLib client does not exist anymore). When true, * it is no longer possible to send requests or receive updates. */ isClosed(): boolean; /** Emit an event. For advanced use only. */ emit: Emit; } export type ClientOptions = { /** Required. Can be obtained at https://my.telegram.org/ */ apiId: number, /** Required. Can be obtained at https://my.telegram.org/ */ apiHash: string, /** * Path to the TDLib's database directory (relative to the current working * directory). Defaults to `'_td_database'`. */ databaseDirectory?: string, /** * Path to the TDLib's files directory (relative to the current working * directory). Defaults to `'_td_files'`. */ filesDirectory?: string, /** An optional key for database encryption. */ databaseEncryptionKey?: string, /** Use test telegram server. */ useTestDc?: boolean, /** * Raw TDLib parameters. These contain fields like application_version, * device_model, etc. Defaults to: * ``` * { use_message_database: true * , use_secret_chats: false * , system_language_code: 'en' * , application_version: '1.0' * , device_model: 'Unknown device' * , system_version: 'Unknown' } * ``` */ tdlibParameters?: TDLibParameters, /** * Advanced option. When set to true, the client does not emit updates if * `connectionState` equals to `connectionStateUpdating`. See also the * `ignore_background_updates` option in TDLib. */ skipOldUpdates?: boolean, } /** * Advanced function. Create a client without handling the initialization auth* * updates. You will need to handle the `authorizationStateWaitTdlibParameters` * update and send parameters manually. A client created by `createClient` * allows invoking requests only after the client options have been sent to * TDLib; this disables that. */ export function createBareClient(): Client export type LoginUser = { type: 'user', /** Handler for `authorizationStateWaitPhoneNumber`, will be recalled on error. */ getPhoneNumber: (retry?: boolean) => Promise, /** Handler for `authorizationStateWaitEmailAddress`, TDLib v1.8.6+ only. */ getEmailAddress: () => Promise, /** Handler for `authorizationStateWaitEmailCode`, TDLib v1.8.6+ only. */ getEmailCode: () => Promise, /** Handler for `authorizationStateWaitOtherDeviceConfirmation`, sends nothing. */ confirmOnAnotherDevice: (link: string) => void, /** Handler for `authorizationStateWaitCode`, will be recalled on error. */ getAuthCode: (retry?: boolean) => Promise, /** Handler for `authorizationStateWaitPassword`, will be recalled on error. */ getPassword: (passwordHint: string, retry?: boolean) => Promise, /** Handler for `authorizationStateWaitRegistration`. */ getName: () => Promise<{ firstName: string, lastName?: string }> } export type LoginBot = { /** You will be logged in as a bot. */ type: 'bot', /** * Handler for `authorizationStateWaitPhoneNumber`, * sends `checkAuthenticationBotToken`, will be recalled on error. */ getToken: (retry?: boolean) => Promise } export type LoginDetails = Partial | LoginBot /** * Error that is sent by TDLib as an `("error", code, message)` triple. * * A `client.invoke` promise can be rejected with an instance of this class; * if the received error is not connected to any request, it is passed to the * `client.on('error', ...)` handler. */ export class TDLibError extends Error { readonly _: 'error'; readonly code: number; constructor(code: number, message: string); } /** * Wraps any non-Error exceptions that were about to be emitted as the * `error` event. */ export class UnknownError extends Error { readonly err: any; private constructor(err: unknown); } export type On = & ((event: 'update', listener: (update: Td$Update) => void) => Client) & ((event: 'error', listener: (err: Error) => void) => Client) & ((event: 'close', listener: () => void) => Client) export type Emit = & ((event: 'update', update: Td$Update) => void) & ((event: 'error', err: Error) => void) & ((event: 'close') => void) export type Off = & ((event: 'update', listener: (...args: any[]) => any) => boolean) & ((event: 'error', listener: (...args: any[]) => any) => boolean) & ((event: 'close', listener: (...args: any[]) => any) => boolean) /** * Initialize the node addon explicitly. This function is entirely optional to * call, TDLib will be initialized automatically on the first call of * `createClient`, `execute`, `setLogMessageCallback`, or `createBareClient`. */ export function init(): void