@tma.js/bridge 2.3.3 → 4.0.0-rc.0

package/dist/dts/env/mockTelegramEnv.d.ts

@@ -1,60 +0,0 @@
-import { LaunchParamsLike } from '@tma.js/transformers';
-import { MethodName, MethodParams } from '../methods/types/index.js';
-/**
- * Mocks the environment and imitates Telegram Mini Apps behavior.
- *
- * We usually use this function in the following cases:
- * 1. We are developing an application outside the Telegram environment and would like to imitate
- * the Telegram client in order to re-create the same communication behavior.
- * 2. We would like to intercept some Telegram Mini Apps methods' calls in order to enhance them
- * or write a custom behavior. It is extremely useful in some Telegram clients improperly handling
- * Mini Apps methods' calls and not even responding.
- *
- * Note that calling this function in Telegram web clients, the `postMessageImplementation` signal
- * value will be updated with a new one, enhancing previously set signal value to allow wrapping
- * the original `window.parent.postMessage` function. In other words, calling `mockTelegramEnv`
- * function N times, you will effectively wrap previously set implementation N times, so be
- * careful calling this function several times during a single lifecycle of the app. In case you
- * would like to avoid such kind of behavior, use the `resetPostMessage` option.
- */
-export declare function mockTelegramEnv({ launchParams, onEvent, resetPostMessage }?: {
-    /**
-     * Launch parameters to mock. They will be saved in the storage, so the SDK functions could
-     * retrieve them.
-     *
-     * Note that this value must have `tgWebAppData` presented in a raw format as long as you will
-     * need it when retrieving init data in this format. Otherwise, init data may be broken.
-     */
-    launchParams?: (Omit<LaunchParamsLike, 'tgWebAppData'> & {
-        tgWebAppData?: string | URLSearchParams;
-    }) | string | URLSearchParams;
-    /**
-     * Function that will be called if a Mini Apps method call was requested by the mini app.
-     *
-     * It receives a Mini Apps method name along with the passed payload.
-     *
-     * Note that using the `next` function, in non-web environments it uses the
-     * `window.TelegramWebviewProxy.postEvent` method.
-     *
-     * Talking about the web versions of Telegram, the value of `next` is a bit more complex - it
-     * will be equal to the value stored in the `postMessageImpl` signal set previously. By default,
-     * this value contains a function utilizing the `window.parent.postMessage` method.
-     * @param event - event information.
-     * @param next - function to call the original method used to call a Mini Apps method.
-     */
-    onEvent?: (event: {
-        [M in MethodName]: {
-            name: M;
-            params: MethodParams<M>;
-        };
-    }[MethodName] | {
-        name: string;
-        params: unknown;
-    }, next: () => void) => void;
-    /**
-     * Removes all previously set enhancements of the `window.parent.postMessage` function set
-     * by other `mockTelegramEnv` calls.
-     * @default false
-     */
-    resetPostMessage?: boolean;
-}): void;

package/dist/dts/events/createEmitter.d.ts

@@ -1,58 +0,0 @@
-import { If, IsNever, IsUndefined, Or } from '@tma.js/toolkit';
-import { Handler } from 'mitt';
-export type WildcardHandler<E> = Handler<{
-    [K in keyof E]: {
-        name: K;
-        payload: If<Or<IsNever<E[K]>, IsUndefined<E[K]>>, never, E[K]>;
-    };
-}[keyof E]>;
-export interface OnFn<E> {
-    /**
-     * Adds a new listener for the specified event.
-     * @param type - event name.
-     * @param handler - event listener.
-     * @param once - should this listener be called only once.
-     * @returns Function to remove bound event listener.
-     */
-    <K extends keyof E>(type: K, handler: Handler<E[K]>, once?: boolean): VoidFunction;
-    /**
-     * Adds a listener to the wildcard event.
-     * @param type - event name.
-     * @param handler - event listener.
-     * @param once - should this listener be called only once.
-     * @returns Function to remove bound event listener.
-     */
-    (type: '*', handler: WildcardHandler<E>, once?: boolean): VoidFunction;
-}
-export interface OffFn<E> {
-    /**
-     * Removes a listener from the specified event.
-     * @param type - event to listen.
-     * @param handler - event listener to remove.
-     * @param once - had this listener to be called only once.
-     */
-    <K extends keyof E>(type: K, handler: Handler<E[K]>, once?: boolean): void;
-    /**
-     * Removes a listener from the wildcard event.
-     * @param type - event to stop listening.
-     * @param handler - event listener to remove.
-     * @param once - should this listener be called only once.
-     */
-    (type: '*', handler: WildcardHandler<E>, once?: boolean): void;
-}
-export interface EmitFn<E> {
-    <K extends keyof E>(type: K, event: E[K]): void;
-    <K extends keyof E>(type: undefined extends E[K] ? K : never): void;
-}
-/**
- * Creates a new enhanced event emitter.
- * @param onFirst - a function to call every time when the events map appeared to be empty during
- * the event listener creation.
- * @param onEmpty - a function to call every tume when the events map became empty.
- */
-export declare function createEmitter<E extends object>(onFirst: VoidFunction, onEmpty: VoidFunction): {
-    on: OnFn<E>;
-    off: OffFn<E>;
-    emit: EmitFn<E>;
-    clear: VoidFunction;
-};

package/dist/dts/events/emitEvent.d.ts

@@ -1,33 +0,0 @@
-import { EventPayload, EventWithoutPayload, EventWithPayload } from './types/index.js';
-/**
- * Emits an event without payload sent from the Telegram native application like it was sent in
- * a default web environment between two iframes.
- *
- * It dispatches a new MessageEvent and expects it to be handled via
- * the `window.addEventListener('message', ...)` call, as a developer would do it to handle
- * messages sent from the parent iframe.
- * @param eventType - event name.
- */
-export declare function emitEvent<E extends EventWithoutPayload>(eventType: E): void;
-/**
- * Emits an event with payload sent from the Telegram native application like it was sent in
- * a default web environment between two iframes.
- *
- * It dispatches a new MessageEvent and expects it to be handled via
- * the `window.addEventListener('message', ...)` call, as a developer would do it to handle
- * messages sent from the parent iframe.
- * @param eventType - event name.
- * @param eventData - event payload.
- */
-export declare function emitEvent<E extends EventWithPayload>(eventType: E, eventData: EventPayload<E>): void;
-/**
- * Emits an unknown event sent from the Telegram native application like it was sent in a default
- * web environment between two iframes.
- *
- * It dispatches a new MessageEvent and expects it to be handled via
- * the `window.addEventListener('message', ...)` call, as a developer would do it to handle
- * messages sent from the parent iframe.
- * @param eventType - event name.
- * @param eventData - event payload.
- */
-export declare function emitEvent<E extends string>(eventType: E, eventData: E extends EventWithoutPayload ? never : E extends EventWithPayload ? EventPayload<E> : unknown): void;

package/dist/dts/events/emitter.d.ts

@@ -1,2 +0,0 @@
-import { Events } from './types/index.js';
-export declare const on: import('./createEmitter.js').OnFn<Events>, off: import('./createEmitter.js').OffFn<Events>, emit: import('./createEmitter.js').EmitFn<Events>, offAll: VoidFunction;

package/dist/dts/events/types/index.d.ts

@@ -1,3 +0,0 @@
-export type * from './events.js';
-export type * from './listening.js';
-export type * from './misc.js';

package/dist/dts/events/types/listening.d.ts

@@ -1,5 +0,0 @@
-import { Handler } from 'mitt';
-import { WildcardHandler } from '../createEmitter.js';
-import { EventName, EventPayload, Events } from './index.js';
-export type EventListener<E extends EventName> = Handler<EventPayload<E>>;
-export type SubscribeListener = WildcardHandler<Events>;

package/dist/dts/events/types/misc.d.ts

@@ -1,16 +0,0 @@
-export type InvoiceStatus = 'paid' | 'failed' | 'pending' | 'cancelled' | string;
-export type PhoneRequestedStatus = 'sent' | 'cancelled' | string;
-export type EmojiStatusAccessRequestedStatus = 'allowed' | string;
-export type EmojiStatusFailedError = 'SUGGESTED_EMOJI_INVALID' | 'USER_DECLINED' | string;
-export type WriteAccessRequestedStatus = 'allowed' | string;
-export type BiometryType = 'finger' | 'face' | string;
-export type BiometryTokenUpdateStatus = 'updated' | 'removed' | 'failed' | string;
-export type BiometryAuthRequestStatus = 'failed' | 'authorized' | string;
-export type FullScreenErrorStatus = 'ALREADY_FULLSCREEN' | 'UNSUPPORTED' | string;
-export interface SafeAreaInsets {
-    top: number;
-    bottom: number;
-    left: number;
-    right: number;
-}
-export type HomeScreenStatus = 'unsupported' | 'unknown' | 'added' | 'missed' | string;

package/dist/dts/globals.d.ts

@@ -1,53 +0,0 @@
-import { Logger } from '@tma.js/toolkit';
-/**
- * The current debug mode state.
- *
- * To update the value, use the `setDebug` function.
- * @see setDebug
- */
-export declare const debug: import('@tma.js/signals').Computed<boolean>;
-/**
- * Sets the package debug mode.
- *
- * Enabling debug mode leads to printing additional messages in the console related to the
- * processes inside the package.
- * @param value - enable debug mode.
- */
-export declare function setDebug(value: boolean): void;
-/**
- * The current target origin used by the `postEvent` method.
- *
- * You don't need to override this value until you know what you are doing.
- * To update the value, use the `setTargetOrigin` function.
- * @default 'https://web.telegram.org'
- * @see setTargetOrigin
- */
-export declare const targetOrigin: import('@tma.js/signals').Computed<string>;
-/**
- * Sets a new target origin that is being used when calling the `postEvent` function in Telegram
- * web versions.
- *
- * You don't need to override this value until you know what you are doing.
- * @param origin - allowed target origin value.
- * @see _targetOrigin
- */
-export declare function setTargetOrigin(origin: string): void;
-/**
- * Signal containing a custom implementation of the method to post a message to the parent
- * window. We usually use it to send a message in web versions of Telegram.
- *
- * @default A function behaving like the `window.parent.postMessage` method.
- */
-export declare const postMessageImpl: import('@tma.js/signals').Signal<{
-    (message: any, targetOrigin: string, transfer?: Transferable[]): void;
-    (message: any, options?: WindowPostMessageOptions): void;
-}>;
-/**
- * The package logger. You can override this value in order to use your own implementation.
- */
-export declare const logger: import('@tma.js/signals').Signal<Logger>;
-/**
- * Resets the package global values. Normally, you don't use this function in your application.
- * We are using it only for test purposes.
- */
-export declare function resetGlobals(): void;

package/dist/dts/methods/captureSameReq.d.ts

@@ -1,10 +0,0 @@
-type CaptureSameReqFn = (payload: {
-    req_id: string;
-}) => boolean;
-/**
- * Returns a function which can be used in `request` function `capture` property to capture
- * the event with the same request identifier.
- * @param reqId - request identifier.
- */
-export declare function captureSameReq(reqId: string): CaptureSameReqFn;
-export {};

package/dist/dts/methods/createPostEvent.d.ts

@@ -1,30 +0,0 @@
-import { Version } from '@tma.js/types';
-import { PostEventFn } from './postEvent.js';
-import { MethodName, MethodNameWithVersionedParams, MethodVersionedParams } from './types/index.js';
-export type OnUnsupportedFn = (data: {
-    version: Version;
-} & ({
-    method: MethodName;
-} | {
-    [M in MethodNameWithVersionedParams]: {
-        method: M;
-        param: MethodVersionedParams<M>;
-    };
-}[MethodNameWithVersionedParams])) => void;
-export type CreatePostEventMode = 'strict' | 'non-strict';
-/**
- * Creates a function that checks if the specified method and parameters are supported.
- *
- * If the method or parameters are unsupported, the `onUnsupported` function will be called.
- *
- * If `strict` or `non-strict` value was passed as the second argument, the function
- * will create its own `onUnsupported` function with behavior depending on the value passed.
- *
- * - Passing `strict` will make the function to throw a `MethodParameterUnsupportedError`
- * or a `MethodUnsupportedError` error.
- * - Passing `non-strict` will just warn you about something being unsupported.
- *
- * @param version - Telegram Mini Apps version.
- * @param onUnsupportedOrMode - function or strict mode. Default: `strict`
- */
-export declare function createPostEvent(version: Version, onUnsupportedOrMode?: OnUnsupportedFn | CreatePostEventMode): PostEventFn;

package/dist/dts/methods/getReleaseVersion.d.ts

@@ -1,15 +0,0 @@
-import { Version } from '@tma.js/types';
-import { MethodName, MethodNameWithVersionedParams, MethodVersionedParams } from './types/index.js';
-/**
- * @returns Version of the specified method parameter release. Returns `null`
- * if passed method or parameter are unknown.
- * @param method - method name
- * @param param - method parameter
- */
-export declare function getReleaseVersion<M extends MethodNameWithVersionedParams>(method: M, param: MethodVersionedParams<M>): Version | null;
-/**
- * @returns Version of the specified method release. Returns `null`
- * if passed method is unknown.
- * @param method - method name.
- */
-export declare function getReleaseVersion(method: MethodName): Version | null;

package/dist/dts/methods/postEvent.d.ts

@@ -1,35 +0,0 @@
-import { either as E } from 'fp-ts';
-import { UnknownEnvError } from '../errors.js';
-import { MethodNameWithOptionalParams, MethodNameWithoutParams, MethodNameWithRequiredParams, MethodParams } from './types/index.js';
-export type PostEventError = UnknownEnvError;
-export type PostEventFn = typeof postEvent;
-export type PostEventFpFn = typeof postEventFp;
-/**
- * @see postEventFp
- */
-export declare function postEvent<Method extends MethodNameWithRequiredParams>(method: Method, params: MethodParams<Method>): void;
-/**
- * @see postEventFp
- */
-export declare function postEvent(method: MethodNameWithoutParams): void;
-/**
- * @see postEventFp
- */
-export declare function postEvent<Method extends MethodNameWithOptionalParams>(method: Method, params?: MethodParams<Method>): void;
-/**
- * Calls Mini Apps methods requiring parameters.
- * @param method - method name.
- * @param params - options along with params.
- */
-export declare function postEventFp<Method extends MethodNameWithRequiredParams>(method: Method, params: MethodParams<Method>): E.Either<PostEventError, void>;
-/**
- * Calls Mini Apps methods accepting no parameters at all.
- * @param method - method name.
- */
-export declare function postEventFp(method: MethodNameWithoutParams): E.Either<PostEventError, void>;
-/**
- * Calls Mini Apps methods accepting optional parameters.
- * @param method - method name.
- * @param params - options along with params.
- */
-export declare function postEventFp<Method extends MethodNameWithOptionalParams>(method: Method, params?: MethodParams<Method>): E.Either<PostEventError, void>;

package/dist/dts/methods/postMessage.d.ts

@@ -1,7 +0,0 @@
-export type PostMessage = typeof window.parent.postMessage;
-/**
- * Posts a message to the parent window. We usually use it to send a message in web versions of
- * Telegram.
- * @param args - `window.parent.postMessage` arguments.
- */
-export declare const postMessage: PostMessage;

package/dist/dts/methods/supports.d.ts

@@ -1,15 +0,0 @@
-import { Version } from '@tma.js/types';
-import { MethodName, MethodNameWithVersionedParams, MethodVersionedParams } from './types/index.js';
-/**
- * Returns true in case, passed parameter in specified method is supported.
- * @param method - method name
- * @param param - method parameter
- * @param inVersion - platform version.
- */
-export declare function supports<M extends MethodNameWithVersionedParams>(method: M, param: MethodVersionedParams<M>, inVersion: Version): boolean;
-/**
- * Returns true in case, specified method is supported in a passed version.
- * @param method - method name.
- * @param inVersion - platform version.
- */
-export declare function supports(method: MethodName, inVersion: Version): boolean;

package/dist/dts/methods/types/custom-method.d.ts

@@ -1,59 +0,0 @@
-interface CreateInvokeCustomMethodParams<M extends string, Params extends object> {
-    /**
-     * Unique request identifier.
-     */
-    req_id: string;
-    /**
-     * Method name.
-     */
-    method: M;
-    /**
-     * Method specific parameters.
-     */
-    params: Params;
-}
-export interface CustomMethodsParams {
-    /**
-     * Deletes storage values using their keys.
-     */
-    deleteStorageValues: {
-        keys: string | string[];
-    };
-    /**
-     * Returns the current server time.
-     */
-    getCurrentTime: {};
-    /**
-     * Gets the current user contact in case, the mini app has access to it.
-     */
-    getRequestedContact: {};
-    /**
-     * Gets all registered storage keys.
-     */
-    getStorageKeys: {};
-    /**
-     * Gets storage values using their keys.
-     */
-    getStorageValues: {
-        keys: string | string[];
-    };
-    /**
-     * Saves a value using specified key in the storage.
-     */
-    saveStorageValue: {
-        key: string;
-        value: string;
-    };
-}
-/**
- * Known custom method name.
- */
-export type CustomMethodName = keyof CustomMethodsParams;
-/**
- * Custom method parameters.
- */
-export type CustomMethodParams<M extends CustomMethodName> = CustomMethodsParams[M];
-export type AnyInvokeCustomMethodParams = CreateInvokeCustomMethodParams<string, any> | {
-    [M in CustomMethodName]: CreateInvokeCustomMethodParams<M, CustomMethodParams<M>>;
-}[CustomMethodName];
-export {};

package/dist/dts/methods/types/index.d.ts

@@ -1,6 +0,0 @@
-export type * from './custom-method.js';
-export type * from './haptic-feedback.js';
-export type * from './methods.js';
-export type * from './misc.js';
-export type * from './popup.js';
-export type { CreateMethodParams } from './utils.js';

package/dist/dts/methods/types/misc.d.ts

@@ -1,27 +0,0 @@
-import { RGB } from '@tma.js/types';
-type KnownColorKey = 'bg_color' | 'secondary_bg_color';
-/**
- * Color key which could be used to update header color.
- */
-export type HeaderColorKey = KnownColorKey;
-/**
- * Color key which could be used to update Mini App background color.
- */
-export type BackgroundColor = RGB;
-/**
- * Color key which could be used to update bottom bar background color.
- */
-export type BottomBarColor = RGB;
-/**
- * Position of the secondary button related to the main one.
- */
-export type SecondaryButtonPosition = 'left' | 'right' | 'top' | 'bottom';
-/**
- * Values expected by the `web_app_open_link.try_browser` option.
- */
-export type OpenLinkBrowser = 'google-chrome' | 'chrome' | 'mozilla-firefox' | 'firefox' | 'microsoft-edge' | 'edge' | 'opera' | 'opera-mini' | 'brave' | 'brave-browser' | 'duckduckgo' | 'duckduckgo-browser' | 'samsung' | 'samsung-browser' | 'vivaldi' | 'vivaldi-browser' | 'kiwi' | 'kiwi-browser' | 'uc' | 'uc-browser' | 'tor' | 'tor-browser';
-/**
- * Chat type which could be used when calling `web_app_switch_inline_query` method.
- */
-export type SwitchInlineQueryChatType = 'users' | 'bots' | 'groups' | 'channels';
-export {};

package/dist/dts/methods/types/utils.d.ts

@@ -1,9 +0,0 @@
-type UnionKeys<T> = T extends T ? keyof T : never;
-/**
- * Creates Mini Apps method parameters types.
- */
-export interface CreateMethodParams<Params = never, VersionedParam extends UnionKeys<Params> = never> {
-    params: Params;
-    versionedParams: VersionedParam;
-}
-export {};

package/dist/dts/obj-prop-helpers.d.ts

@@ -1,39 +0,0 @@
-/**
- * Defines a property, that is a functions compose. Trying to set a value in this property
- * will lead to adding it to a function's pool. The property value will always be equal to a
- * function, calling all collected functions in the pool.
- *
- * Returned function performs a cleanup. It does one of the following:
- * 1. Removes the property if no functions were to the pool added other than the initial one.
- * 2. Sets the value equal to the first added function to the pool after the initial one if
- * the only one additional function was added at all. In other words, if the pool length is equal
- * to 2, the second item will be selected as the property value.
- * 3. Leaves the value equal to a function calling all pool functions, but removes the initially
- * added one.
- * @param obj - object.
- * @param propertyName - object property.
- * @param initialFn - an initial function to set.
- */
-export declare function defineFnComposer(obj: any, propertyName: string, initialFn: (...args: any) => any): void;
-/**
- * Wires the specified property in the object preventing it from being overwritten. Instead, it
- * enhances the previous value by merging the current one with the passed one.
- * @param obj - object.
- * @param prop - object property to rewire.
- */
-export declare function defineMergeableProperty(obj: any, prop: string): void;
-/**
- * Defines an enumerable and configurable property with a getter and setter.
- * @param obj - object.
- * @param prop - object property name.
- * @param get - getter to use.
- * @param set - setter to use.
- */
-export declare function defineProxiedProperty(obj: any, prop: string, get: () => unknown, set: (v: any) => void): void;
-/**
- * Defines an enumerable, configurable and writable property with the initial value.
- * @param obj - object.
- * @param prop - object property name.
- * @param value - value to set.
- */
-export declare function defineStaticProperty(obj: any, prop: string, value: any): void;

package/dist/dts/utils/compareVersions.d.ts

@@ -1,10 +0,0 @@
-import { Version } from '@tma.js/types';
-/**
- * @param a - first version.
- * @param b - second version.
- * @returns
- * - `1` if the version "a" is greater than "b".
- * - `0` the version "a" is equal to "b".
- * - `-1` the version "a" is lower than "b".
- */
-export declare function compareVersions(a: Version, b: Version): number;

package/dist/dts/utils/invokeCustomMethod.d.ts

@@ -1,34 +0,0 @@
-import { BetterPromise } from 'better-promises';
-import { taskEither as TE } from 'fp-ts';
-import { InvokeCustomMethodFailedError } from '../errors.js';
-import { CustomMethodName, CustomMethodParams } from '../methods/types/index.js';
-import { Request2Error, Request2FpOptions, Request2Options } from './request2.js';
-export type InvokeCustomMethodError = Request2Error | InvokeCustomMethodFailedError;
-export type InvokeCustomMethodOptions = Omit<Request2Options<'custom_method_invoked'>, 'capture'>;
-export type InvokeCustomMethodFn = typeof invokeCustomMethod;
-export type InvokeCustomMethodFpOptions = Omit<Request2FpOptions<'custom_method_invoked'>, 'capture'>;
-export type InvokeCustomMethodFpFn = typeof invokeCustomMethodFp;
-/**
- * Invokes known custom method. Returns method execution result.
- * @param method - method name.
- * @param params - method parameters.
- * @param requestId - request identifier.
- * @param options - additional options.
- */
-export declare function invokeCustomMethodFp<M extends CustomMethodName>(method: M, params: CustomMethodParams<M>, requestId: string, options?: InvokeCustomMethodFpOptions): TE.TaskEither<InvokeCustomMethodError, unknown>;
-/**
- * Invokes unknown custom method. Returns method execution result.
- * @param method - method name.
- * @param params - method parameters.
- * @param requestId - request identifier.
- * @param options - additional options.
- */
-export declare function invokeCustomMethodFp(method: string, params: object, requestId: string, options?: InvokeCustomMethodFpOptions): TE.TaskEither<Request2Error, unknown>;
-/**
- * @see invokeCustomMethodFp
- */
-export declare function invokeCustomMethod<M extends CustomMethodName>(method: M, params: CustomMethodParams<M>, requestId: string, options?: InvokeCustomMethodOptions): BetterPromise<unknown>;
-/**
- * @see invokeCustomMethodFp
- */
-export declare function invokeCustomMethod(method: string, params: object, requestId: string, options?: InvokeCustomMethodOptions): BetterPromise<unknown>;

package/dist/dts/utils/request.d.ts

@@ -1,102 +0,0 @@
-import { If, IsNever } from '@tma.js/toolkit';
-import { BetterPromise, BetterPromiseOptions, TimeoutError } from 'better-promises';
-import { taskEither as TE } from 'fp-ts';
-import { EventName, EventPayload } from '../events/types/index.js';
-import { PostEventError, PostEventFn, PostEventFpFn } from '../methods/postEvent.js';
-import { MethodNameWithOptionalParams, MethodNameWithoutParams, MethodNameWithRequiredParams, MethodParams } from '../methods/types/index.js';
-type AnyEventName = EventName | EventName[];
-export type RequestError = PostEventError | TimeoutError;
-/**
- * @example
- * { event: 'scan_qr_closed' }
- * @example
- * {
- *   event: 'popup_closed',
- *   payload: { button_id: 'ok' }
- * }
- */
-export type RequestCaptureFnEventsPayload<E extends EventName[]> = E extends (infer U extends EventName)[] ? {
-    [K in U]: If<IsNever<EventPayload<K>>, {
-        event: K;
-    }, {
-        event: K;
-        payload: EventPayload<K>;
-    }>;
-}[U] : never;
-export type RequestCaptureEventsFn<E extends EventName[]> = (payload: RequestCaptureFnEventsPayload<E>) => boolean;
-export type RequestCaptureEventFn<E extends EventName> = If<IsNever<EventPayload<E>>, () => boolean, (payload: EventPayload<E>) => boolean>;
-export type RequestCaptureFn<E extends AnyEventName> = E extends EventName[] ? RequestCaptureEventsFn<E> : E extends EventName ? RequestCaptureEventFn<E> : never;
-export interface RequestOptions<E extends AnyEventName> extends Omit<RequestFpOptions<E>, 'postEvent'> {
-    /**
-     * Custom function to call mini apps methods.
-     */
-    postEvent?: PostEventFn;
-}
-export type RequestResult<E extends AnyEventName> = E extends (infer U extends EventName)[] ? U extends infer K extends EventName ? If<IsNever<EventPayload<K>>, undefined, EventPayload<K>> : never : E extends EventName ? If<IsNever<EventPayload<E>>, undefined, EventPayload<E>> : never;
-export interface RequestFpOptions<E extends AnyEventName> extends Pick<BetterPromiseOptions, 'abortSignal' | 'timeout'> {
-    /**
-     * A function that should return true if the event should be captured.
-     * The first compatible request will be captured if this property is omitted.
-     */
-    capture?: RequestCaptureFn<E>;
-    /**
-     * A custom function to call mini apps methods.
-     */
-    postEvent?: PostEventFpFn;
-}
-export type RequestFn = typeof request;
-export type RequestFpFn = typeof requestFp;
-/**
- * Calls a method waiting for the specified event(-s) to occur.
- * @param method - method name.
- * @param eventOrEvents - tracked event or events.
- * @param options - additional options.
- * @deprecated To be removed in the next major update. Use `request2fp` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function requestFp<M extends MethodNameWithRequiredParams, E extends AnyEventName, AbortError = never>(method: M, eventOrEvents: E, options: RequestFpOptions<E> & {
-    params: MethodParams<M>;
-}): TE.TaskEither<RequestError | AbortError, RequestResult<E>>;
-/**
- * Calls a method waiting for the specified event(-s) to occur.
- * @param method - method name.
- * @param eventOrEvents - tracked event or events.
- * @param options - additional options.
- * @deprecated To be removed in the next major update. Use `request2fp` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function requestFp<M extends MethodNameWithOptionalParams, E extends AnyEventName, AbortError = never>(method: M, eventOrEvents: E, options?: RequestFpOptions<E> & {
-    params?: MethodParams<M>;
-}): TE.TaskEither<RequestError | AbortError, RequestResult<E>>;
-/**
- * Calls a method waiting for the specified event(-s) to occur.
- * @param method - method name.
- * @param eventOrEvents - tracked event or events.
- * @param options - additional options.
- * @deprecated To be removed in the next major update. Use `request2fp` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function requestFp<M extends MethodNameWithoutParams, E extends AnyEventName, AbortError = never>(method: M, eventOrEvents: E, options?: RequestFpOptions<E>): TE.TaskEither<RequestError | AbortError, RequestResult<E>>;
-/**
- * @see requestFp
- * @deprecated To be removed in the next major update. Use `request2` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function request<M extends MethodNameWithRequiredParams, E extends AnyEventName>(method: M, eventOrEvents: E, options: RequestOptions<E> & {
-    params: MethodParams<M>;
-}): BetterPromise<RequestResult<E>>;
-/**
- * @see requestFp
- * @deprecated To be removed in the next major update. Use `request2` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function request<M extends MethodNameWithOptionalParams, E extends AnyEventName>(method: M, eventOrEvents: E, options?: RequestOptions<E> & {
-    params?: MethodParams<M>;
-}): BetterPromise<RequestResult<E>>;
-/**
- * @see requestFp
- * @deprecated To be removed in the next major update. Use `request2` instead, it provides
- * a proper way of handling multiple events.
- */
-export declare function request<M extends MethodNameWithoutParams, E extends AnyEventName>(method: M, eventOrEvents: E, options?: RequestOptions<E>): BetterPromise<RequestResult<E>>;
-export {};