mtcute

https://ref.mtcute.dev/
Admin
mtcute is a modern, performant, and lightweight TypeScript library and bot framework for the MTProto...
Tokens:1,731,464
Snippets:15,534
Trust Score:5.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Optional setup Method

Source: https://ref.mtcute.dev/interfaces/_mtcute_bun.index.IStorageDriver.html

The optional setup method initializes the driver, providing a logger instance and platform information. This method is synchronous.

```typescript
setup?: (log: Logger, platform: ICorePlatform) => void
```

--------------------------------

### start

Source: https://ref.mtcute.dev/funcs/_mtcute_core.highlevel_methods.start.html

Starts the client in an interactive manner, handling login, sign-up, and 2FA. It accepts a client instance and a parameters object with various callbacks and options for authorization.

```APIDOC
## start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FV. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly.

### Method
`start(client: ITelegramClient, params: { ... }): Promise<User>`

### Parameters
#### `params` Object
- **abortSignal** (AbortSignal) - Optional - Abort signal.
- **botToken** (MaybeDynamic<string>) - Optional - Bot token to use. Ignored if `phone` is supplied.
- **code** (MaybeDynamic<string>) - Optional - Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
- **codeSentCallback** ((code: SentCode) => MaybePromise<void>) - Optional - Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code. Default: `console.log`.
- **codeSettings** (Omit<RawCodeSettings, "_" | "logoutTokens">) - Optional - Additional code settings to pass to the server.
- **forceSms** (boolean) - Optional - Whether to force code delivery through SMS.
- **futureAuthTokens** (Uint8Array<ArrayBufferLike>[]) - Optional - Saved future auth tokens, if any.
- **invalidCodeCallback** ((type: "code" | "password") => MaybePromise<void>) - Optional - If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
- **password** (MaybeDynamic<string>) - Optional - 2FA password. Ignored if `botToken` is supplied.
- **phone** (MaybeDynamic<string>) - Optional - Phone number of the account. If account does not exist, it will be created.
- **qrCodeHandler** ((url: string, expires: Date) => void) - Optional - When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
- **session** (string | InputStringSessionData) - Optional - String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
- **sessionForce** (boolean) - Optional - Whether to overwrite existing session.

### Returns
Promise<User>
```

--------------------------------

### start

Source: https://ref.mtcute.dev/classes/_mtcute_web.index.TelegramClient.html

Starts the client in an interactive manner, handling login, sign up, and 2FA. This method is suitable for interactive applications. It supports both user and bot accounts.

```APIDOC
## start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FA. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly. **Available** : ✅ both users and bots

### Method
start

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* params: {
    * abortSignal?: AbortSignal
    * botToken?: MaybeDynamic<string>
    * code?: MaybeDynamic<string>
    * codeSentCallback?: (code: SentCode) => MaybePromise<void>
    * codeSettings?: Omit<RawCodeSettings, "_" | "logoutTokens">
    * forceSms?: boolean
    * futureAuthTokens?: Uint8Array<ArrayBufferLike>[]
    * invalidCodeCallback?: (type: "code" | "password") => MaybePromise<void>
    * password?: MaybeDynamic<string>
    * phone?: MaybeDynamic<string>
    * qrCodeHandler?: (url: string, expires: Date) => void
    * session?: string | InputStringSessionData
    * sessionForce?: boolean
}
  * ##### `Optional`abortSignal?: AbortSignal
    Abort signal
  * ##### `Optional`botToken?: MaybeDynamic<string>
    Bot token to use. Ignored if `phone` is supplied.
  * ##### `Optional`code?: MaybeDynamic<string>
    Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
  * ##### `Optional`codeSentCallback?: (code: SentCode) => MaybePromise<void>
    Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code. Default: `console.log`.
  * ##### `Optional`codeSettings?: Omit<RawCodeSettings, "_" | "logoutTokens">
    Additional code settings to pass to the server
  * ##### `Optional`forceSms?: boolean
    Whether to force code delivery through SMS
  * ##### `Optional`futureAuthTokens?: Uint8Array<ArrayBufferLike>[]
    Saved future auth tokens, if any
  * ##### `Optional`invalidCodeCallback?: (type: "code" | "password") => MaybePromise<void>
    If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
  * ##### `Optional`password?: MaybeDynamic<string>
    2FA password. Ignored if `botToken` is supplied
  * ##### `Optional`phone?: MaybeDynamic<string>
    Phone number of the account. If account does not exist, it will be created
  * ##### `Optional`qrCodeHandler?: (url: string, expires: Date) => void
    When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
  * ##### `Optional`session?: string | InputStringSessionData
    String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
  * ##### `Optional`sessionForce?: boolean
    Whether to overwrite existing session.

### Request Example
None

### Response
#### Success Response (200)
* User

#### Response Example
None
```

--------------------------------

### start

Source: https://ref.mtcute.dev/modules/_mtcute_web.methods.html

Starts a service or process.

```APIDOC
## start

### Description
Starts a service or process.

### Method
APIDOC

### Endpoint
APIDOC

### Parameters
APIDOC

### Request Example
APIDOC

### Response
APIDOC

#### Response Example
APIDOC
```

--------------------------------

### start

Source: https://ref.mtcute.dev/classes/_mtcute_core.highlevel_client.TelegramClient

Starts the client in an interactive and declarative manner, handling login, sign up, and 2FA. It supports both user and bot accounts and allows for dynamic parameter provision.

```APIDOC
## start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FV. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly.

**Available** : ✅ both users and bots

### Parameters
#### Params
- **abortSignal** (AbortSignal) - Optional - Abort signal
- **botToken** (MaybeDynamic<string>) - Optional - Bot token to use. Ignored if `phone` is supplied.
- **code** (MaybeDynamic<string>) - Optional - Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
- **codeSentCallback** ((code: SentCode) => MaybePromise<void>) - Optional - Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code. Default: `console.log`.
- **codeSettings** (Omit<RawCodeSettings, "_" | "logoutTokens">) - Optional - Additional code settings to pass to the server
- **forceSms** (boolean) - Optional - Whether to force code delivery through SMS
- **futureAuthTokens** (Uint8Array<ArrayBufferLike>[]) - Optional - Saved future auth tokens, if any
- **invalidCodeCallback** ((type: "code" | "password") => MaybePromise<void>) - Optional - If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
- **password** (MaybeDynamic<string>) - Optional - 2FA password. Ignored if `botToken` is supplied
- **phone** (MaybeDynamic<string>) - Optional - Phone number of the account. If account does not exist, it will be created
- **qrCodeHandler** ((url: string, expires: Date) => void) - Optional - When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
- **session** (string | InputStringSessionData) - Optional - String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
- **sessionForce** (boolean) - Optional - Whether to overwrite existing session.

### Returns
Promise<User>
```

--------------------------------

### start(client, params)

Source: https://ref.mtcute.dev/funcs/_mtcute_bun.methods.start.html

Starts the MTUte client in an interactive manner, handling authorization details through provided callbacks. This method supports login, sign-up, and 2FA.

```APIDOC
## Function start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FV. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly.

### Parameters
* `client`: ITelegramClient
* `params`: {
  `abortSignal`?: AbortSignal;
  `botToken`?: MaybeDynamic<string>;
  `code`?: MaybeDynamic<string>;
  `codeSentCallback`?: (code: SentCode) => MaybePromise<void>;
  `codeSettings`?: Omit<RawCodeSettings, "_" | "logoutTokens">
  `forceSms`?: boolean;
  `futureAuthTokens`?: Uint8Array<ArrayBufferLike>[];
  `invalidCodeCallback`?: (type: "code" | "password") => MaybePromise<void>;
  `password`?: MaybeDynamic<string>;
  `phone`?: MaybeDynamic<string>;
  `qrCodeHandler`?: (url: string, expires: Date) => void;
  `session`?: string | InputStringSessionData;
  `sessionForce`?: boolean;
}

#### Parameter Details:
* `abortSignal` (AbortSignal) - Optional - Abort signal.
* `botToken` (MaybeDynamic<string>) - Optional - Bot token to use. Ignored if `phone` is supplied.
* `code` (MaybeDynamic<string>) - Optional - Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
* `codeSentCallback` ((code: SentCode) => MaybePromise<void>) - Optional - Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code. Default: `console.log`.
* `codeSettings` (Omit<RawCodeSettings, "_" | "logoutTokens">) - Optional - Additional code settings to pass to the server.
* `forceSms` (boolean) - Optional - Whether to force code delivery through SMS.
* `futureAuthTokens` (Uint8Array<ArrayBufferLike>[]) - Optional - Saved future auth tokens, if any.
* `invalidCodeCallback` ((type: "code" | "password") => MaybePromise<void>) - Optional - If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
* `password` (MaybeDynamic<string>) - Optional - 2FA password. Ignored if `botToken` is supplied.
* `phone` (MaybeDynamic<string>) - Optional - Phone number of the account. If account does not exist, it will be created.
* `qrCodeHandler` ((url: string, expires: Date) => void) - Optional - When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
* `session` (string | InputStringSessionData) - Optional - String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
* `sessionForce` (boolean) - Optional - Whether to overwrite existing session.

### Returns
Promise<User>
```

--------------------------------

### start

Source: https://ref.mtcute.dev/funcs/_mtcute_node.methods.start.html

Starts the MTProto client in an interactive manner, handling authorization details via callbacks. This method supports login, sign-up, and 2FA.

```APIDOC
## start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FV. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly.

### Method
Not Applicable (SDK Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **client**: ITelegramClient - The Telegram client instance.
* **params**: object - An object containing authorization parameters and callbacks.
    * **abortSignal**?: AbortSignal - Abort signal to cancel the operation.
    * **botToken**?: MaybeDynamic<string> - Bot token to use. Ignored if `phone` is supplied.
    * **code**?: MaybeDynamic<string> - Code sent to the phone. Must be present if `phone` is supplied and `botToken` is not.
    * **codeSentCallback**?: (code: SentCode) => MaybePromise<void> - Callback invoked when a code is sent. Defaults to `console.log`.
    * **codeSettings**?: Omit<RawCodeSettings, "_" | "logoutTokens"> - Additional code settings.
    * **forceSms**?: boolean - Whether to force code delivery through SMS.
    * **futureAuthTokens**?: Uint8Array<ArrayBufferLike>[] - Saved future auth tokens.
    * **invalidCodeCallback**?: (type: "code" | "password") => MaybePromise<void> - Callback for invalid code or 2FA password.
    * **password**?: MaybeDynamic<string> - 2FA password. Ignored if `botToken` is supplied.
    * **phone**?: MaybeDynamic<string> - Phone number of the account. If the account does not exist, it will be created.
    * **qrCodeHandler**?: (url: string, expires: Date) => void - Handler for QR login flow.
    * **session**?: string | InputStringSessionData - String session to import.
    * **sessionForce**?: boolean - Whether to overwrite an existing session.

### Returns
* **Promise<User>** - A promise that resolves to the User object upon successful authorization.
```

--------------------------------

### Clone mtcute repository and install dependencies

Source: https://ref.mtcute.dev/guide/topics/keyboards.html

Set up the development environment by cloning the repository, selecting a Node.js version, installing dependencies, and generating TL schema code.

```bash
git clone https://github.com/mtcute/mtcute  
fnm use # or `nvm use`  
cd mtcute  
pnpm install --frozen-lockfile  

# generate code from tl schema  
pnpm -C packages/core run gen-tl
```

--------------------------------

### Clone mtcute repository and install dependencies

Source: https://ref.mtcute.dev/guide/topics/modules.html

Sets up the development environment for mtcute by cloning the repository, installing dependencies, and generating TL schema code.

```bash
git clone https://github.com/mtcute/mtcute  
fnm use # or `nvm use`  
cd mtcute  
pnpm install --frozen-lockfile  
  
# generate code from tl schema  
pnpm -C packages/core run gen-tl
```

--------------------------------

### start

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.TelegramClient.html

Starts the Telegram client in an interactive manner, handling login, sign-up, and 2FA. This method is suitable for both users and bots and can be customized with various callbacks for authorization details.

```APIDOC
## start

### Description
Start the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FV. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly. **Available** : ✅ both users and bots

### Method
start

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* params: {
  * abortSignal?: AbortSignal;
  * botToken?: MaybeDynamic<string>;
  * code?: MaybeDynamic<string>;
  * codeSentCallback?: (code: SentCode) => MaybePromise<void>;
  * codeSettings?: Omit<RawCodeSettings, "_" | "logoutTokens">;
  * forceSms?: boolean;
  * futureAuthTokens?: Uint8Array<ArrayBufferLike>[];
  * invalidCodeCallback?: (type: "code" | "password") => MaybePromise<void>;
  * password?: MaybeDynamic<string>;
  * phone?: MaybeDynamic<string>;
  * qrCodeHandler?: (url: string, expires: Date) => void;
  * session?: string | InputStringSessionData;
  * sessionForce?: boolean;
} = {}
  * ##### `Optional`abortSignal?: AbortSignal
Abort signal
  * ##### `Optional`botToken?: MaybeDynamic<string>
Bot token to use. Ignored if `phone` is supplied.
  * ##### `Optional`code?: MaybeDynamic<string>
Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
  * ##### `Optional`codeSentCallback?: (code: SentCode) => MaybePromise<void>
Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code.
#### Default
`console.log`.
  * ##### `Optional`codeSettings?: Omit<RawCodeSettings, "_" | "logoutTokens">
Additional code settings to pass to the server
  * ##### `Optional`forceSms?: boolean
Whether to force code delivery through SMS
  * ##### `Optional`futureAuthTokens?: Uint8Array<ArrayBufferLike>[]
Saved future auth tokens, if any
  * ##### `Optional`invalidCodeCallback?: (type: "code" | "password") => MaybePromise<void>
If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
  * ##### `Optional`password?: MaybeDynamic<string>
2FA password. Ignored if `botToken` is supplied
  * ##### `Optional`phone?: MaybeDynamic<string>
Phone number of the account. If account does not exist, it will be created
  * ##### `Optional`qrCodeHandler?: (url: string, expires: Date) => void
When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
  * ##### `Optional`session?: string | InputStringSessionData
String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
  * ##### `Optional`sessionForce?: boolean
Whether to overwrite existing session.

### Returns Promise<User>
```

--------------------------------

### Install @mtcute/postgres and pg

Source: https://ref.mtcute.dev/modules/_mtcute_postgres

Install the necessary packages for using the PostgreSQL storage provider with mtcute.

```bash
pnpm add @mtcute/postgres pg
```

--------------------------------

### start

Source: https://ref.mtcute.dev/classes/_mtcute_deno.index.Conversation.html

Initiates the conversation.

```APIDOC
## start

### Description
Starts the conversation.

### Method
`start`
```

--------------------------------

### setup method

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.BaseStorageDriver.html

Sets up the driver, passing the logger instance and platform.

```APIDOC
## setup
  * setup(log: Logger, platform: ICorePlatform): void
Setup the driver, passing the logger instance, in case your driver needs it
#### Parameters
    * log: Logger
    * platform: ICorePlatform
#### Returns void
```

--------------------------------

### Bot Interactions

Source: https://ref.mtcute.dev/funcs/_mtcute_bun.index.networkMiddlewares.onMethod

Functions for starting bots, getting bot results, and sending inline bot results.

```APIDOC
## messages.startBot

### Description
Starts a conversation with a bot.

### Method
Not specified (assumed to be part of an SDK or RPC interface)

## messages.getInlineBotResults

### Description
Retrieves inline results from a bot.

### Method
Not specified (assumed to be part of an SDK or RPC interface)

## messages.setInlineBotResults

### Description
Sets the inline results for a bot.

### Method
Not specified (assumed to be part of an SDK or RPC interface)

## messages.sendInlineBotResult

### Description
Sends an inline bot result as a message.

### Method
Not specified (assumed to be part of an SDK or RPC interface)
```

--------------------------------

### setup

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.SqliteStorageDriver.html

Sets up the driver with logger and platform instances.

```APIDOC
## setup

### Description
Setup the driver, passing the logger instance, in case your driver needs it

### Signature
setup(log: Logger, platform: ICorePlatform): void

### Parameters
- **log** (Logger) - The logger instance.
- **platform** (ICorePlatform) - The platform instance.

### Returns
void
```

--------------------------------

### getState (by key)

Source: https://ref.mtcute.dev/classes/_mtcute_dispatcher.WizardScene.html

Gets the update state object for a given key. For custom keys, use a prefix starting with '$' to avoid conflicts. This method is synchronous.

```APIDOC
## getState (by key)

### Description
Gets the update state object for a given key. For custom keys, use a prefix starting with '$' to avoid conflicts. This method is synchronous.

### Method
`getState<S extends object = State & WizardInternalState>(key: string): UpdateState<S>`

### Type Parameters
- **S extends object = State & WizardInternalState** - State type, defaults to dispatcher's state type. Only checked at compile-time

### Parameters
#### Path Parameters
- **key** (string) - Required - State storage key

### Returns
- **UpdateState<S>**
```

--------------------------------

### TelegramTransport Interface

Source: https://ref.mtcute.dev/interfaces/_mtcute_deno.index.TelegramTransport.html

Provides methods to connect to Telegram data centers and to get a packet codec for a given data center. It also includes an optional setup method for crypto and logging.

```APIDOC
## Interface TelegramTransport

### Description

The `TelegramTransport` interface defines the core methods for interacting with Telegram transport layers. It allows establishing connections to data centers and obtaining packet codecs.

### Methods

#### `connect`

Establishes a connection to a specified Telegram data center.

- **Parameters**
  - `dc` (BasicDcOption) - The data center option to connect to.
- **Returns**
  - `Promise<ITelegramConnection>` - A promise that resolves with the Telegram connection.

#### `packetCodec`

Retrieves the packet codec for a given data center.

- **Parameters**
  - `dc` (BasicDcOption) - The data center option for which to get the codec.
- **Returns**
  - `IPacketCodec` - The packet codec instance.

#### `setup` (Optional)

An optional method to set up cryptographic providers and logging.

- **Parameters**
  - `crypto` (ICryptoProvider) - The crypto provider to use.
  - `log` (Logger) - The logger instance.
- **Returns**
  - `void`
```

--------------------------------

### setup

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.PaddedIntermediatePacketCodec.html

Optional method to set up crypto providers and logging before other operations.

```APIDOC
## Method: setup

### setup?(crypto: ICryptoProvider): void

Sets up crypto functions and/or logging. This method is called before any other operations.

#### Parameters

* **crypto** (ICryptoProvider) - The crypto provider to use.

#### Returns

* void
```

--------------------------------

### BaseSqliteStorageDriver.setup

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.BaseSqliteStorageDriver.html

Sets up the driver with a logger instance and platform information.

```APIDOC
## setup(log: Logger, platform: ICorePlatform)

### Description
Setup the driver, passing the logger instance, in case your driver needs it.

### Parameters
#### Path Parameters
- **log** (Logger) - Required - The logger instance.
- **platform** (ICorePlatform) - Required - The platform interface.

### Returns
- **void**
```

--------------------------------

### start

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.Conversation.html

Initiates or starts the conversation.

```APIDOC
## start

### Description
Start the conversation.

### Returns
Promise<void>
```

--------------------------------

### setup

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.ObfuscatedPacketCodec.html

Sets up the codec with crypto functions and logging. This method is called before any other operations.

```APIDOC
## setup

### Description
For codecs that use crypto functions and/or logging. This method is called before any other.

### Parameters
* **crypto** (ICryptoProvider) - The crypto provider to use.
* **log** (Logger) - The logger instance to use.

### Returns
void
```

--------------------------------

### Predicate Example

Source: https://ref.mtcute.dev/interfaces/_mtcute_tl-utils.index.TlTypeModifiers.html

Provides an example of a predicate, which is used to specify a condition or flag associated with an argument.

```typescript
`flags.3`
```

--------------------------------

### iterInviteLinks

Source: https://ref.mtcute.dev/classes/_mtcute_core.highlevel_client.TelegramClient

Iterate over invite links created by some administrator in the chat. As an administrator you can only get your own links, as a creator you can get any other admin's links.

```APIDOC
## iterInviteLinks

### Description
Iterate over invite links created by some administrator in the chat. As an administrator you can only get your own links (i.e. `adminId = "self"`), as a creator you can get any other admin's links.

### Method
`iterInviteLinks(chatId: InputPeerLike, params?: { admin?: InputPeerLike; limit?: number; offset?: GetInviteLinksOffset; revoked?: boolean; } & { chunkSize?: number; limit?: number })`

### Parameters
#### Path Parameters
- **chatId** (InputPeerLike) - Required - Chat ID

#### Query Parameters
- **params** (object) - Optional
  - **admin** (InputPeerLike) - Optional - Only return this admin's links. Default: `"self"`
  - **limit** (number) - Optional - Limit the number of invite links to be fetched. Default: `100`
  - **offset** (GetInviteLinksOffset) - Optional - Offset for pagination.
  - **revoked** (boolean) - Optional - Whether to fetch revoked invite links
  - **chunkSize** (number) - Optional - Size of chunks which are fetched. Usually not needed. Default: `100`
  - **limit** (number) - Optional - Limit the number of invite links to be fetched. By default, all links are fetched.

### Returns
AsyncIterableIterator<ChatInviteLink>
```

--------------------------------

### setup

Source: https://ref.mtcute.dev/interfaces/_mtcute_node.index.ITelegramConnection.html

Optionally sets up the transport with cryptographic providers and a logger. This method is called before any other and is crucial for initializing the connection's security and logging.

```APIDOC
## setup

### Description
Provides crypto and logging for the transport. Not done in constructor to simplify factory. This method is called before any other.

### Method
`setup?(crypto: ICryptoProvider, log: Logger): void`

### Parameters
#### Path Parameters
* `crypto` (ICryptoProvider) - The cryptographic provider to use.
* `log` (Logger) - The logger instance to use for logging.
```

--------------------------------

### start

Source: https://ref.mtcute.dev/funcs/_mtcute_web.methods.start.html

Starts the client in an interactive and declarative manner by providing callbacks for authorization details. This method handles login, sign-up, and 2FA. All parameters are `MaybeDynamic<T>`, meaning you can supply either `T` or a function that returns `MaybePromise<T>`. This method is intended for interactive login; for headless services, use underlying authorization methods directly.

```APIDOC
## start

### Description
Starts the client in an interactive and declarative manner, by providing callbacks for authorization details. This method handles both login and sign up, and also handles 2FA. All parameters are `MaybeDynamic<T>`, meaning you can either supply `T`, or a function that returns `MaybePromise<T>`. This method is intended for _interactive_ login. If you are building some kind of headless service, you will most likely want to use the underlying authorization methods directly.

### Method
start

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **client**: ITelegramClient
* **params**: {
    * **abortSignal** (AbortionSignal) - Optional - Abort signal
    * **botToken** (MaybeDynamic<string>) - Optional - Bot token to use. Ignored if `phone` is supplied.
    * **code** (MaybeDynamic<string>) - Optional - Code sent to the phone (either sms, call, flash call or other). Ignored if `botToken` is supplied, must be present if `phone` is supplied.
    * **codeSentCallback** ((code: SentCode) => MaybePromise<void>) - Optional - Custom method that is called when a code is sent. Can be used to show a GUI alert of some kind. This method is called _before_ start.params.code. Default: `console.log`.
    * **codeSettings** (Omit<RawCodeSettings, "_" | "logoutTokens">) - Optional - Additional code settings to pass to the server
    * **forceSms** (boolean) - Optional - Whether to force code delivery through SMS
    * **futureAuthTokens** (Uint8Array<ArrayBufferLike>[]) - Optional - Saved future auth tokens, if any
    * **invalidCodeCallback** ((type: "code" | "password") => MaybePromise<void>) - Optional - If passed, this function will be called if provided code or 2FA password was invalid. New code/password will be requested later. If provided `code`/`password` is a constant string, providing an invalid one will interrupt authorization flow.
    * **password** (MaybeDynamic<string>) - Optional - 2FA password. Ignored if `botToken` is supplied
    * **phone** (MaybeDynamic<string>) - Optional - Phone number of the account. If account does not exist, it will be created
    * **qrCodeHandler** ((url: string, expires: Date) => void) - Optional - When passed, QR login flow will be used instead of the regular login flow. This function will be called whenever the login URL is changed, and the app is expected to display it as a QR code to the user.
    * **session** (string | InputStringSessionData) - Optional - String session exported using TelegramClient.exportSession. This simply calls TelegramClient.importSession before anything else. Note that passed session will be ignored in case storage already contains authorization.
    * **sessionForce** (boolean) - Optional - Whether to overwrite existing session.
}

### Request Example
None

### Response
#### Success Response (200)
* **User** (User) - Description of the User object returned upon successful authorization.

#### Response Example
None
```

--------------------------------

### Extract Raw Get Future Chat Creator After Leave Request

Source: https://ref.mtcute.dev/funcs/_mtcute_bun.index.networkMiddlewares.onMethod.html

Extracts raw requests for getting future chat creator information after leaving.

```APIDOC
## Extract<RawGetFutureChatCreatorAfterLeaveRequest, { _: T }>

### Description
Extracts raw requests for retrieving future chat creator information after a user has left.

### Method
Not specified (assumed internal SDK method)

### Parameters
- `_: T`: Type parameter for the request.
```

--------------------------------

### start(client: ITelegramClient, params: object): Promise<User>

Source: https://ref.mtcute.dev/funcs/_mtcute_deno.methods.start.html

Starts the client in an interactive manner, handling login, sign-up, and 2FA. It accepts various parameters to customize the authorization process, including callbacks for code sending, invalid codes, and QR code handling. All parameters can be dynamic, meaning they can be a value or a function returning a value.

```APIDOC
## Function start

### Signature
start(
  client: ITelegramClient,
  params: {
    abortSignal?: AbortSignal;
    botToken?: MaybeDynamic<string>;
    code?: MaybeDynamic<string>;
    codeSentCallback?: (code: SentCode) => MaybePromise<void>;
    codeSettings?: Omit<RawCodeSettings, "_" | "logoutTokens">;
    forceSms?: boolean;
    futureAuthTokens?: Uint8Array<ArrayBufferLike>[];
    invalidCodeCallback?: (type: "code" | "password") => MaybePromise<void>;
    password?: MaybeDynamic<string>;
    phone?: MaybeDynamic<string>;
    qrCodeHandler?: (url: string, expires: Date) => void;
    session?: string | InputStringSessionData;
    sessionForce?: boolean;
  },
): Promise<User>

### Description
Starts the client in an interactive and declarative manner by providing callbacks for authorization details. This method handles both login and sign up, as well as 2FA. All parameters are `MaybeDynamic<T>`, meaning you can supply `T` or a function that returns `MaybePromise<T>`. This method is intended for interactive login; for headless services, use underlying authorization methods directly.

### Parameters

*   **client**: `ITelegramClient` - The Telegram client instance.
*   **params**: `object` - An object containing authorization parameters:
    *   **`Optional` abortSignal**: `AbortSignal` - An abort signal to cancel the operation.
    *   **`Optional` botToken**: `MaybeDynamic<string>` - Bot token to use. Ignored if `phone` is supplied.
    *   **`Optional` code**: `MaybeDynamic<string>` - Code sent to the phone. Ignored if `botToken` is supplied, must be present if `phone` is supplied.
    *   **`Optional` codeSentCallback**: `(code: SentCode) => MaybePromise<void>` - Custom callback called when a code is sent, before `start.params.code` is processed. Defaults to `console.log`.
    *   **`Optional` codeSettings**: `Omit<RawCodeSettings, "_" | "logoutTokens">` - Additional code settings to pass to the server.
    *   **`Optional` forceSms**: `boolean` - Whether to force code delivery through SMS.
    *   **`Optional` futureAuthTokens**: `Uint8Array<ArrayBufferLike>[]` - Saved future auth tokens, if any.
    *   **`Optional` invalidCodeCallback**: `(type: "code" | "password") => MaybePromise<void>` - Callback for invalid codes or 2FA passwords. If provided `code`/`password` is a constant string, an invalid one will interrupt the flow.
    *   **`Optional` password**: `MaybeDynamic<string>` - 2FA password. Ignored if `botToken` is supplied.
    *   **`Optional` phone**: `MaybeDynamic<string>` - Phone number of the account. If the account does not exist, it will be created.
    *   **`Optional` qrCodeHandler**: `(url: string, expires: Date) => void` - Callback to handle QR login flow. Called whenever the login URL changes.
    *   **`Optional` session**: `string | InputStringSessionData` - String session exported using `TelegramClient.exportSession`. Calls `TelegramClient.importSession` first. Ignored if storage already contains authorization.
    *   **`Optional` sessionForce**: `boolean` - Whether to overwrite an existing session.

### Returns
*   `Promise<User>` - A promise that resolves with the `User` object upon successful authorization.
```

--------------------------------

### startUpdatesLoop

Source: https://ref.mtcute.dev/classes/_mtcute_bun.index.BaseTelegramClient.html

Starts the loop for fetching updates from the server.

```APIDOC
### `async`startUpdatesLoop
[async] startUpdatesLoop(): Promise<void>
```

--------------------------------

### setBusinessIntro

Source: https://ref.mtcute.dev/classes/_mtcute_deno.index.TelegramClient.html

Sets the current user's business introduction, including an optional description, sticker, and title. Can also be used to remove the introduction by passing null.

```APIDOC
## setBusinessIntro

### Description
Sets the current user's business introduction. This can include a description, a sticker, and a title. To remove the introduction, pass `null`.

### Method
`setBusinessIntro(intro: { description?: string; sticker?: TypeInputDocument | InputFileLike | InputMediaSticker; title?: string; } | null): Promise<void>`

### Parameters
#### Path Parameters
* `intro` (object | null) - Required - Introduction parameters, or `null` to remove.
  * `description` (string) - Optional - Description of the introduction.
  * `sticker` (TypeInputDocument | InputFileLike | InputMediaSticker) - Optional - Sticker to show beneath the introduction.
  * `title` (string) - Optional - Title of the introduction.

### Returns
Promise<void>
```

--------------------------------

### Audio Constructor

Source: https://ref.mtcute.dev/classes/_mtcute_deno.index.Audio.html

Initializes a new Audio object.

```APIDOC
## constructor
  * new Audio(doc: RawDocument, attr: RawDocumentAttributeAudio): Audio
#### Parameters
    * doc: RawDocument
    * attr: RawDocumentAttributeAudio
TL object describing the audio
#### Returns Audio
```

--------------------------------

### startLoop

Source: https://ref.mtcute.dev/classes/_mtcute_web.index.UpdatesManager.html

Starts the updates loop. Ensure updates processing is enabled before calling this method. It's recommended to use this method in a callback to start or ensure the user is logged in.

```APIDOC
## startLoop

### Description
Start updates loop.

You must first call enableUpdatesProcessing to use this method.
It is recommended to use this method in callback to start, or otherwise make sure the user is logged in.

> **Note** : If you are using UpdatesManagerParams.catchUp option, catching up will be done in background, you can't await it. Instead, listen for the `updating` and `connected` connection state events.

### Method
```
startLoop(): Promise<void>
```
```

--------------------------------

### prepare

Source: https://ref.mtcute.dev/interfaces/_mtcute_node.index.ITelegramClient.html

Prepares the client for use. This method should be called after initialization and before connecting.

```APIDOC
## prepare

### Description
Prepares the client for use.

### Method
prepare

### Returns
Promise<void> - A promise that resolves when the client is prepared.
```

--------------------------------

### AllStories Accessors

Source: https://ref.mtcute.dev/classes/_mtcute_core.index.AllStories.html

Provides methods to check for more stories, get pagination details, retrieve peer stories, access stealth mode information, and get the total count of stories.

```APIDOC
## Accessors

### `hasMore`
* **Description**: Checks if there are more stories to fetch.
* **Returns**: `boolean` - True if more stories are available, false otherwise.

### `next`
* **Description**: Gets the next offset for pagination.
* **Returns**: `string` - The next offset value.

### `peerStories`
* **Description**: Retrieves a list of peers and their associated stories.
* **Returns**: `PeerStories[]` - An array of PeerStories objects.

### `stealthMode`
* **Description**: Gets information about the stealth mode status.
* **Returns**: `StoriesStealthMode | null` - Stealth mode information or null if not in stealth mode.

### `total`
* **Description**: Gets the total number of available PeerStories.
* **Returns**: `number` - The total count of PeerStories.
```

--------------------------------

### AllStories Accessors

Source: https://ref.mtcute.dev/classes/_mtcute_node.index.AllStories.html

Provides methods to check for more stories, get the next pagination offset, retrieve peer stories, access stealth mode information, and get the total count of stories.

```APIDOC
## Accessors

### `hasMore`
- **hasMore** (boolean) - Returns `true` if there are more stories to fetch, `false` otherwise.

### `next`
- **next** (string) - Returns the next offset for pagination.

### `peerStories`
- **peerStories** (PeerStories[]) - Returns an array of PeerStories, each containing information about a peer and their stories.

### `stealthMode`
- **stealthMode** (StoriesStealthMode | null) - Returns information about the stealth mode, or `null` if stealth mode is not active.

### `total`
- **total** (number) - Returns the total number of PeerStories available.
```

--------------------------------

### BaseMtProxyTransport.setup

Source: https://ref.mtcute.dev/classes/_mtcute_web.index.BaseMtProxyTransport.html

Sets up the transport with crypto and logging providers.

```APIDOC
## setup

### Description
Sets up the transport with crypto and logging providers.

### Parameters
#### Path Parameters
* **crypto** (ICryptoProvider) - Required
* **log** (Logger) - Required

### Returns
void
```

--------------------------------

### setup Method - IPacketCodec

Source: https://ref.mtcute.dev/interfaces/_mtcute_bun.index.IPacketCodec.html

Optional method to set up the codec with crypto provider and logger. Called before any other methods.

```typescript
setup?(crypto: ICryptoProvider, log: Logger): void
```

--------------------------------

### startTest

Source: https://ref.mtcute.dev/modules/_mtcute_bun.methods.html

Starts a test.

```APIDOC
## startTest

### Description
Starts a test.

### Method
(Not specified in source)

### Endpoint
(Not specified in source)

### Parameters
(Not specified in source)

### Request Example
(Not specified in source)

### Response
(Not specified in source)
```

--------------------------------

### _initialize

Source: https://ref.mtcute.dev/classes/_mtcute_deno.index.BaseSqliteStorageDriver.html

Internal method to initialize the storage driver.

```APIDOC
### _initialize
  * _initialize(): void
#### Returns void
```

--------------------------------

### goToStep

Source: https://ref.mtcute.dev/classes/_mtcute_dispatcher.WizardScene.html

Navigates to a specific step within the wizard state.

```APIDOC
## goToStep

### Description
Navigates to a specific step within the wizard state.

### Method
`goToStep(state: UpdateState<WizardInternalState>, step: number): Promise<void>`

### Parameters
#### Path Parameters
- **state** (UpdateState<WizardInternalState>) - Required - The current wizard state
- **step** (number) - Required - The target step number

### Returns
- **Promise<void>**
```

--------------------------------

### getPeers

Source: https://ref.mtcute.dev/modules/_mtcute_core.highlevel_methods.html

Gets peers.

```APIDOC
## getPeers

### Description
Gets peers.

### Method
getPeers

### Parameters
None explicitly documented.

### Response
Success Response (200)
- Details not explicitly documented.
```

--------------------------------

### constructor

Source: https://ref.mtcute.dev/classes/_mtcute_node.index.MtClient.html

Initializes a new MtClient instance.

```APIDOC
## constructor

### Description
Initializes a new MtClient instance.

### Parameters
- **params** (MtClientOptions & { onError: (err: unknown) => void }) - Required - Configuration options for the client, including an error handler.

### Returns
- MtClient - The newly created MtClient instance.
```

--------------------------------

### getMessages

Source: https://ref.mtcute.dev/modules/_mtcute_core.highlevel_methods.html

Gets messages.

```APIDOC
## getMessages

### Description
Gets messages.

### Method
getMessages

### Parameters
None explicitly documented.

### Response
Success Response (200)
- Details not explicitly documented.
```

--------------------------------

### getContacts

Source: https://ref.mtcute.dev/modules/_mtcute_core.highlevel_methods.html

Gets contacts.

```APIDOC
## getContacts

### Description
Gets contacts.

### Method
getContacts

### Parameters
None explicitly documented.

### Response
Success Response (200)
- Details not explicitly documented.
```

--------------------------------

### ITelegramConnection.setup Method

Source: https://ref.mtcute.dev/interfaces/_mtcute_bun.index.ITelegramConnection.html

An optional method to provide crypto and logging dependencies to the transport. This is called before any other method to ensure dependencies are available.

```typescript
setup?(crypto: ICryptoProvider, log: Logger): void;
```

--------------------------------

### Example of onMethod usage

Source: https://ref.mtcute.dev/funcs/_mtcute_web.index.networkMiddlewares.onMethod.html

This example demonstrates how to use `onMethod` to intercept the 'help.getNearestDc' RPC method and return a custom response. Note the use of `as const` for the `_` property to ensure proper type inference.

```typescript
onMethod('help.getNearestDc', async () => ({
  _: 'nearestDc' as const, // (otherwise ts will infer this as `string` and will complain)
  country: 'RU',
  thisDc: 2,
  nearestDc: 2,
}))
```
Tokens:
Raw