@tma.js/sdk 2.7.0 → 3.0.1

package/dist/dts/features/Viewport/Viewport.d.ts

@@ -0,0 +1,220 @@
+import { BetterPromise } from 'better-promises';
+import { SafeAreaInsets, EventListener, RequestError, PostEventError } from '@tma.js/bridge';
+import { Computed } from '@tma.js/signals';
+import { WithStateRestore } from '../../fn-options/withStateRestore.js';
+import { AsyncOptions } from '../../types.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithVersion } from '../../fn-options/withVersion.js';
+import { WithRequest } from '../../fn-options/withRequest.js';
+import { CSSVarsBoundError, FullscreenFailedError } from '../../errors.js';
+import { WithPostEvent } from '../../fn-options/withPostEvent.js';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+type FullscreenError = FullscreenFailedError | RequestError;
+type ViewportChangedEventListener = EventListener<'viewport_changed'>;
+type FullscreenChangedEventListener = EventListener<'fullscreen_changed'>;
+type SafeAreaInsetsChangedEventListener = EventListener<'safe_area_changed'>;
+type SafeAreaInsetCSSVarKey = `safeAreaInset${Capitalize<keyof SafeAreaInsets>}`;
+export type GetCSSVarNameKey = 'width' | 'height' | 'stableHeight' | SafeAreaInsetCSSVarKey | `content${Capitalize<SafeAreaInsetCSSVarKey>}`;
+export type GetCSSVarNameFn = (key: GetCSSVarNameKey) => string | null | undefined | false;
+export interface ViewportState {
+    contentSafeAreaInsets: SafeAreaInsets;
+    height: number;
+    isExpanded: boolean;
+    isFullscreen: boolean;
+    safeAreaInsets: SafeAreaInsets;
+    stableHeight: number;
+    width: number;
+}
+type WithListeners<On extends string, Off extends string, L> = {
+    [K in On | Off]: (listener: L) => void;
+};
+export interface ViewportOptions<EViewportStable, EFullscreen> extends WithStateRestore<ViewportState>, WithVersion, WithRequest, WithPostEvent, WithListeners<'onViewportChanged', 'offViewportChanged', ViewportChangedEventListener>, WithListeners<'onFullscreenChanged', 'offFullscreenChanged', FullscreenChangedEventListener>, WithListeners<'onSafeAreaInsetsChanged', 'offSafeAreaInsetsChanged', SafeAreaInsetsChangedEventListener>, WithListeners<'onContentSafeAreaInsetsChanged', 'offContentSafeAreaInsetsChanged', SafeAreaInsetsChangedEventListener>, SharedFeatureOptions {
+    /**
+     * True if the viewport is stable.
+     */
+    isViewportStable: boolean | (() => E.Either<EViewportStable, boolean>);
+    /**
+     * True if the application was opened in fullscreen initially.
+     */
+    isFullscreen: boolean | (() => E.Either<EFullscreen, boolean>);
+}
+export declare class Viewport<EViewportStable, EFullscreen> {
+    constructor({ storage, isPageReload, onContentSafeAreaInsetsChanged, onSafeAreaInsetsChanged, onViewportChanged, onFullscreenChanged, offContentSafeAreaInsetsChanged, offFullscreenChanged, offSafeAreaInsetsChanged, offViewportChanged, request, isViewportStable, isFullscreen, isTma, version, postEvent, }: ViewportOptions<EViewportStable, EFullscreen>);
+    /**
+     * Complete component state.
+     */
+    readonly state: Computed<ViewportState>;
+    /**
+     * Signal containing the current height of the **visible area** of the Mini App.
+     *
+     * The application can display just the top part of the Mini App, with its
+     * lower part remaining outside the screen area. From this position, the user
+     * can "pull" the Mini App to its maximum height, while the bot can do the same
+     * by calling `expand` method. As the position of the Mini App changes, the
+     * current height value of the visible area will be updated  in real time.
+     *
+     * Please note that the refresh rate of this value is not sufficient to
+     * smoothly follow the lower border of the window. It should not be used to pin
+     * interface elements to the bottom of the visible area. It's more appropriate
+     * to use the value of the `stableHeight` field for this purpose.
+     *
+     * @see stableHeight
+     */
+    readonly height: Computed<number>;
+    /**
+     * Signal containing the height of the visible area of the Mini App in its last stable state.
+     *
+     * The application can display just the top part of the Mini App, with its
+     * lower part remaining outside the screen area. From this position, the user
+     * can "pull" the Mini App to its maximum height, while the application can do
+     * the same by calling `expand` method.
+     *
+     * Unlike the value of `height`, the value of `stableHeight` does not change as
+     * the position of the Mini App changes with user gestures or during
+     * animations. The value of `stableHeight` will be updated after all gestures
+     * and animations are completed and the Mini App reaches its final size.
+     *
+     * @see height
+     */
+    readonly stableHeight: Computed<number>;
+    /**
+     * Signal containing the currently visible area width.
+     */
+    readonly width: Computed<number>;
+    /**
+     * Signal indicating if the Mini App is expanded to the maximum available height. Otherwise,
+     * if the Mini App occupies part of the screen and can be expanded to the full
+     * height using the `expand` method.
+     */
+    readonly isExpanded: Computed<boolean>;
+    /**
+     * Signal indicating if the current viewport height is stable and is not going to change in
+     * the next moment.
+     */
+    readonly isStable: Computed<boolean>;
+    /**
+     * Signal containing content safe area insets.
+     */
+    readonly contentSafeAreaInsets: Computed<SafeAreaInsets>;
+    /**
+     * Signal containing top content safe area inset.
+     */
+    readonly contentSafeAreaInsetTop: Computed<number>;
+    /**
+     * Signal containing left content safe area inset.
+     */
+    readonly contentSafeAreaInsetLeft: Computed<number>;
+    /**
+     * Signal containing right content safe area inset.
+     */
+    readonly contentSafeAreaInsetRight: Computed<number>;
+    /**
+     * Signal containing bottom content safe area inset.
+     */
+    readonly contentSafeAreaInsetBottom: Computed<number>;
+    /**
+     * Signal containing safe area insets.
+     */
+    readonly safeAreaInsets: Computed<SafeAreaInsets>;
+    /**
+     * Signal containing top safe area inset.
+     */
+    readonly safeAreaInsetTop: Computed<number>;
+    /**
+     * Signal containing left safe area inset.
+     */
+    readonly safeAreaInsetLeft: Computed<number>;
+    /**
+     * Signal containing right safe area inset.
+     */
+    readonly safeAreaInsetRight: Computed<number>;
+    /**
+     * Signal containing bottom safe area inset.
+     */
+    readonly safeAreaInsetBottom: Computed<number>;
+    /**
+     * Signal indicating if the viewport is currently in fullscreen mode.
+     */
+    readonly isFullscreen: Computed<boolean>;
+    /**
+     * Requests fullscreen mode for the mini application.
+     * @since Mini Apps v8.0
+     */
+    readonly requestFullscreenFp: WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<FullscreenError, void>, true>;
+    /**
+     * @see requestFullscreenFp
+     */
+    readonly requestFullscreen: WithChecks<(options?: AsyncOptions) => BetterPromise<void>, true>;
+    /**
+     * Exits mini application from the fullscreen mode.
+     * @since Mini Apps v8.0
+     */
+    readonly exitFullscreenFp: WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<FullscreenError, void>, true>;
+    /**
+     * @see exitFullscreenFp
+     */
+    readonly exitFullscreen: WithChecks<(options?: AsyncOptions) => BetterPromise<void>, true>;
+    /**
+     * Signal indicating if CSS variables are bound.
+     */
+    readonly isCssVarsBound: Computed<boolean>;
+    /**
+     * Creates CSS variables connected with the current viewport.
+     *
+     * By default, created CSS variables names are following the pattern "--tg-theme-{name}", where
+     * {name} is a viewport property name converted from camel case to kebab case.
+     *
+     * Default variables:
+     * - `--tg-viewport-height`
+     * - `--tg-viewport-width`
+     * - `--tg-viewport-stable-height`
+     * - `--tg-viewport-content-safe-area-inset-top`
+     * - `--tg-viewport-content-safe-area-inset-bottom`
+     * - `--tg-viewport-content-safe-area-inset-left`
+     * - `--tg-viewport-content-safe-area-inset-right`
+     * - `--tg-viewport-safe-area-inset-top`
+     * - `--tg-viewport-safe-area-inset-bottom`
+     * - `--tg-viewport-safe-area-inset-left`
+     * - `--tg-viewport-safe-area-inset-right`
+     *
+     * Variables are being automatically updated if the viewport was changed.
+     *
+     * @param getCSSVarName - function, returning computed complete CSS variable name. The CSS
+     * variable will only be defined if the function returned non-empty string value.
+     * @returns Function to stop updating variables.
+     * @example Using no arguments
+     * bindCssVarsFp();
+     * @example Using custom CSS vars generator
+     * bindCssVarsFp(key => `--my-prefix-${key}`);
+     */
+    readonly bindCssVarsFp: WithChecksFp<(getCSSVarName?: GetCSSVarNameFn) => (E.Either<CSSVarsBoundError, VoidFunction>), false>;
+    /**
+     * @see bindCssVarsFp
+     */
+    readonly bindCssVars: WithChecks<(getCSSVarName?: GetCSSVarNameFn) => VoidFunction, false>;
+    /**
+     * Signal indicating if the component is currently mounted.
+     */
+    readonly isMounted: Computed<boolean>;
+    /**
+     * Mounts the component.
+     */
+    readonly mountFp: WithChecksFp<(options?: AsyncOptions) => (TE.TaskEither<EFullscreen | EViewportStable | RequestError, void>), false>;
+    /**
+     * @see mountFp
+     */
+    readonly mount: WithChecks<(options?: AsyncOptions) => BetterPromise<void>, false>;
+    /**
+     * A method that expands the Mini App to the maximum available height. To find
+     * out if the Mini App is expanded to the maximum height, refer to the value of
+     * the `isExpanded`.
+     */
+    readonly expandFp: WithChecksFp<() => E.Either<PostEventError, void>, false>;
+    /**
+     * @see expandFp
+     */
+    readonly expand: WithChecks<() => void, false>;
+}
+export {};

package/dist/dts/features/Viewport/exports.d.ts

@@ -0,0 +1,2 @@
+export { viewport } from './instance.js';
+export { Viewport, type ViewportState, type ViewportOptions } from './Viewport.js';

package/dist/dts/features/Viewport/instance.d.ts

@@ -0,0 +1,2 @@
+import { Viewport } from './Viewport.js';
+export declare const viewport: Viewport<import('@tma.js/bridge').RetrieveLaunchParamsError, import('@tma.js/bridge').RetrieveLaunchParamsError>;

package/dist/dts/features/emoji-status/exports.d.ts

@@ -0,0 +1,2 @@
+export { requestEmojiStatusAccess, requestEmojiStatusAccessFp, } from './requestEmojiStatusAccess.js';
+export { setEmojiStatus, setEmojiStatusFp, type SetEmojiStatusOptions, } from './setEmojiStatus.js';

package/dist/dts/features/emoji-status/requestEmojiStatusAccess.d.ts

@@ -0,0 +1,16 @@
+import { EmojiStatusAccessRequestedStatus, RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+/**
+ * Shows a native popup requesting permission for the bot to manage user's emoji status.
+ * @param options - additional options.
+ * @returns Emoji status access status.
+ * @since Mini Apps v8.0
+ * @example
+ * const status = await requestEmojiStatusAccess();
+ */
+export declare const requestEmojiStatusAccessFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options: AsyncOptions) => TE.TaskEither<RequestError, EmojiStatusAccessRequestedStatus>, true, never>;
+/**
+ * @see requestEmojiStatusAccessFp
+ */
+export declare const requestEmojiStatusAccess: import('../../with-checks/withChecksFp.js').WithChecks<(options: AsyncOptions) => TE.TaskEither<RequestError, EmojiStatusAccessRequestedStatus>, true, never>;

package/dist/dts/features/emoji-status/setEmojiStatus.d.ts

@@ -0,0 +1,28 @@
+import { RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import { SetEmojiStatusError } from '../../errors.js';
+import * as TE from 'fp-ts/TaskEither';
+export interface SetEmojiStatusOptions extends AsyncOptions {
+    duration?: number;
+}
+/**
+ * Opens a dialog allowing the user to set the specified custom emoji as their status.
+ * @returns Nothing if status set was successful.
+ * @param options - additional options.
+ * @since Mini Apps v8.0
+ * @example
+ * pipe(
+ *   setEmojiStatusFp('5361800828313167608'),
+ *   TE.match(error => {
+ *     console.error('Error occurred', error);
+ *   }, () => {
+ *     console.log('Status set');
+ *   }),
+ * );
+ * const statusSet = await setEmojiStatus('5361800828313167608');
+ */
+export declare const setEmojiStatusFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(customEmojiId: string, options?: SetEmojiStatusOptions) => TE.TaskEither<RequestError | SetEmojiStatusError, void>, true, never>;
+/**
+ * @see setEmojiStatusFp
+ */
+export declare const setEmojiStatus: import('../../with-checks/withChecksFp.js').WithChecks<(customEmojiId: string, options?: SetEmojiStatusOptions) => TE.TaskEither<RequestError | SetEmojiStatusError, void>, true, never>;

package/dist/dts/features/home-screen/addToHomeScreen.d.ts

@@ -0,0 +1,11 @@
+import { PostEventError } from '@tma.js/bridge';
+import type * as E from 'fp-ts/Either';
+/**
+ * Prompts the user to add the Mini App to the home screen.
+ * @since Mini Apps v8.0
+ */
+export declare const addToHomeScreenFp: import('../../with-checks/withChecksFp.js').WithChecksFp<() => E.Either<PostEventError, void>, true, never>;
+/**
+ * @see addToHomeScreenFp
+ */
+export declare const addToHomeScreen: import('../../with-checks/withChecksFp.js').WithChecks<() => E.Either<PostEventError, void>, true, never>;

package/dist/dts/features/home-screen/checkHomeScreenStatus.d.ts

@@ -0,0 +1,14 @@
+import { HomeScreenStatus, RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+/**
+ * Sends a request to the native Telegram application to check if the current mini
+ * application is added to the device's home screen.
+ * @param options - additional options.
+ * @since Mini Apps v8.0
+ */
+export declare const checkHomeScreenStatusFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<RequestError, HomeScreenStatus>, true, never>;
+/**
+ * @see checkHomeScreenStatusFp
+ */
+export declare const checkHomeScreenStatus: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<RequestError, HomeScreenStatus>, true, never>;

package/dist/dts/features/home-screen/exports.d.ts

@@ -0,0 +1,2 @@
+export { addToHomeScreenFp, addToHomeScreen } from './addToHomeScreen.js';
+export { checkHomeScreenStatus, checkHomeScreenStatusFp } from './checkHomeScreenStatus.js';

package/dist/dts/features/links/exports.d.ts

@@ -0,0 +1,3 @@
+export { type OpenLinkError, openLinkFp, openLink, type OpenLinkOptions } from './openLink.js';
+export { type OpenTelegramLinkError, openTelegramLinkFp, openTelegramLink, } from './openTelegramLink.js';
+export { shareURLFp, shareURL, type ShareURLError } from './shareURL.js';

package/dist/dts/features/links/openLink.d.ts

@@ -0,0 +1,31 @@
+import { OpenLinkBrowser, PostEventError } from '@tma.js/bridge';
+import { InvalidArgumentsError } from '../../errors.js';
+import * as E from 'fp-ts/Either';
+export interface OpenLinkOptions {
+    /**
+     * Attempts to use the instant view mode.
+     */
+    tryInstantView?: boolean;
+    /**
+     * A preferred browser to open the link in.
+     */
+    tryBrowser?: OpenLinkBrowser;
+}
+export type OpenLinkError = PostEventError | InvalidArgumentsError;
+/**
+ * Opens a link.
+ *
+ * The Mini App will not be closed.
+ *
+ * Note that this method can be called only in response to the user
+ * interaction with the Mini App interface (e.g. click inside the Mini App or on the main button).
+ * @param url - URL to be opened.
+ * @param options - additional options.
+ * @example
+ * openLink('https://google.com', {
+ *   tryInstantView: true,
+ *   tryBrowser: 'chrome',
+ * });
+ */
+export declare const openLinkFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(url: string | URL, options?: OpenLinkOptions) => E.Either<OpenLinkError, void>, false, never>;
+export declare const openLink: import('../../with-checks/withChecksFp.js').WithChecks<(url: string | URL, options?: OpenLinkOptions) => E.Either<OpenLinkError, void>, false, never>;

package/dist/dts/features/links/openTelegramLink.d.ts

@@ -0,0 +1,18 @@
+import { PostEventError } from '@tma.js/bridge';
+import { InvalidArgumentsError } from '../../errors.js';
+import * as E from 'fp-ts/Either';
+export type OpenTelegramLinkError = PostEventError | InvalidArgumentsError;
+/**
+ * Opens a Telegram link inside the Telegram app. The function expects passing a link in a full
+ * format using the hostname "t.me".
+ *
+ * The Mini App will be closed.
+ * @param url - URL to be opened.
+ * @example
+ * openTelegramLink('https://t.me/heyqbnk');
+ */
+export declare const openTelegramLinkFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(url: string | URL) => E.Either<OpenTelegramLinkError, void>, false, never>;
+/**
+ * @see openTelegramLinkFp
+ */
+export declare const openTelegramLink: import('../../with-checks/withChecksFp.js').WithChecks<(url: string | URL) => E.Either<OpenTelegramLinkError, void>, false, never>;

package/dist/dts/features/links/shareURL.d.ts

@@ -0,0 +1,18 @@
+import { PostEventError } from '@tma.js/bridge';
+import type * as E from 'fp-ts/Either';
+export type ShareURLError = PostEventError;
+/**
+ * Shares the specified URL with the passed to the chats, selected by user.
+ * After being called, it closes the mini application.
+ *
+ * This method uses Telegram's Share Links.
+ * @param url - URL to share.
+ * @param text - text to append after the URL.
+ * @see https://core.telegram.org/api/links#share-links
+ * @see https://core.telegram.org/widgets/share#custom-buttons
+ */
+export declare const shareURLFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(url: string, text?: string) => E.Either<ShareURLError, void>, false, never>;
+/**
+ * @see shareURLFp
+ */
+export declare const shareURL: import('../../with-checks/withChecksFp.js').WithChecks<(url: string, text?: string) => E.Either<ShareURLError, void>, false, never>;

package/dist/dts/features/privacy/exports.d.ts

@@ -0,0 +1,3 @@
+export { type RequestContactError, type RequestedContactCompleteData, type RequestedContact, requestContact, requestContactComplete, requestContactCompleteFp, requestContactFp, } from './requestContact.js';
+export { type RequestPhoneAccessError, requestPhoneAccess, requestPhoneAccessFp, } from './requestPhoneAccess.js';
+export { requestWriteAccess, requestWriteAccessFp, type RequestWriteAccessError, } from './requestWriteAccess.js';

package/dist/dts/features/privacy/requestContact.d.ts

@@ -0,0 +1,59 @@
+import { BetterTaskEitherError } from '@tma.js/toolkit';
+import { InvokeCustomMethodError } from '../../fn-options/withInvokeCustomMethod.js';
+import { AccessDeniedError, ValidationError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+/**
+ * Requested contact information.
+ */
+export interface RequestedContact {
+    contact: {
+        user_id: number;
+        phone_number: string;
+        first_name: string;
+        last_name?: string;
+        [key: string]: unknown;
+    };
+    auth_date: Date;
+    hash: string;
+    [key: string]: unknown;
+}
+/**
+ * Requested contact complete data.
+ */
+export interface RequestedContactCompleteData {
+    /**
+     * Raw original representation of the contact data returned from the Telegram server.
+     */
+    raw: string;
+    /**
+     * Parsed representation of the contact data.
+     */
+    parsed: RequestedContact;
+}
+export type RequestContactError = InvokeCustomMethodError | AccessDeniedError | ValidationError | BetterTaskEitherError;
+/**
+ * Requests current user contact information.
+ *
+ * This function returns an object, containing both raw and parsed representations of a response,
+ * received from the Telegram client.
+ * @param options - additional options.
+ * @since Mini Apps v6.9
+ */
+export declare const requestContactCompleteFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<RequestContactError, RequestedContactCompleteData>, true, never>;
+/**
+ * @see requestContactCompleteFp
+ */
+export declare const requestContactComplete: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<RequestContactError, RequestedContactCompleteData>, true, never>;
+/**
+ * Works the same way as the `requestContactCompleteFp` function, but returns only parsed
+ * representation of the contact data.
+ * @see requestContactCompleteFp
+ * @param options - additional options.
+ * @since Mini Apps v6.9
+ */
+export declare const requestContactFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<RequestContactError, RequestedContact>, true, never>;
+/**
+ * @see requestContactFp
+ */
+export declare const requestContact: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<RequestContactError, RequestedContact>, true, never>;

package/dist/dts/features/privacy/requestPhoneAccess.d.ts

@@ -0,0 +1,19 @@
+import { PhoneRequestedStatus, RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+export type RequestPhoneAccessError = RequestError;
+/**
+ * Requests current user phone access. Method returns promise, which resolves
+ * status of the request. In case, user accepted the request, Mini App bot will receive
+ * the according notification.
+ *
+ * To obtain the retrieved information instead, utilize the `requestContact` method.
+ * @param options - additional options.
+ * @since Mini Apps v6.9
+ * @see requestContact
+ */
+export declare const requestPhoneAccessFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<RequestPhoneAccessError, PhoneRequestedStatus>, true, never>;
+/**
+ * @see requestPhoneAccessFp
+ */
+export declare const requestPhoneAccess: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<RequestPhoneAccessError, PhoneRequestedStatus>, true, never>;

package/dist/dts/features/privacy/requestWriteAccess.d.ts

@@ -0,0 +1,14 @@
+import { WriteAccessRequestedStatus, RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+export type RequestWriteAccessError = RequestError;
+/**
+ * Requests write message access to the current user.
+ * @param options - additional options.
+ * @since Mini Apps v6.9
+ */
+export declare const requestWriteAccessFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<RequestWriteAccessError, WriteAccessRequestedStatus>, true, never>;
+/**
+ * @see requestWriteAccessFp
+ */
+export declare const requestWriteAccess: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<RequestWriteAccessError, WriteAccessRequestedStatus>, true, never>;

package/dist/dts/features/uncategorized/copyTextToClipboard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copies specified text to the clipboard.
+ * @param text - text to copy.
+ */
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/dts/features/uncategorized/downloadFile.d.ts

@@ -0,0 +1,21 @@
+import { RequestError } from '@tma.js/bridge';
+import { AccessDeniedError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+export type DownloadFileError = RequestError | AccessDeniedError;
+/**
+ * Displays a native popup prompting the user to download a file.
+ * @param url - the HTTPS URL of the file to be downloaded.
+ * @param file - the suggested name for the downloaded file.
+ * @param options - additional request execution options.
+ * @since Mini Apps v8.0
+ * @example
+ * pipe(
+ *   downloadFileFp('https://telegram.org/js/telegram-web-app.js', 'telegram-sdk.js'),
+ *   TE.map(() => {
+ *     console.log('Downloading');
+ *   })
+ * )
+ */
+export declare const downloadFileFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(url: string, fileName: string, options?: AsyncOptions) => TE.TaskEither<DownloadFileError, void>, true, never>;
+export declare const downloadFile: import('../../with-checks/withChecksFp.js').WithChecks<(url: string, fileName: string, options?: AsyncOptions) => TE.TaskEither<DownloadFileError, void>, true, never>;

package/dist/dts/features/uncategorized/exports.d.ts

@@ -0,0 +1,11 @@
+export { copyTextToClipboard } from './copyTextToClipboard.js';
+export { downloadFile, type DownloadFileError, downloadFileFp } from './downloadFile.js';
+export { getCurrentTime, type GetCurrentTimeError, getCurrentTimeFp } from './getCurrentTime.js';
+export { hideKeyboard, hideKeyboardFp, type HideKeyboardError } from './hideKeyboard.js';
+export { readTextFromClipboard, readTextFromClipboardFp, type ReadTextFromClipboardError, } from './readTextFromClipboard.js';
+export { retrieveAndroidDeviceData } from './retrieveAndroidDeviceData.js';
+export { retrieveAndroidDeviceDataFrom, type AndroidDeviceData, } from './retrieveAndroidDeviceDataFrom.js';
+export { sendData, sendDataFp, type SendDataError } from './sendData.js';
+export { shareMessage, shareMessageFp, type ShareMessageFnError } from './shareMessage.js';
+export { shareStory, shareStoryFp, type ShareStoryOptions, type ShareStoryError, } from './shareStory.js';
+export { switchInlineQuery, switchInlineQueryFp, type SwitchInlineQueryError, } from './switchInlineQuery.js';

package/dist/dts/features/uncategorized/getCurrentTime.d.ts

@@ -0,0 +1,15 @@
+import { InvokeCustomMethodError } from '../../fn-options/withInvokeCustomMethod.js';
+import { AsyncOptions } from '../../types.js';
+import { ValidationError } from '../../errors.js';
+import * as TE from 'fp-ts/TaskEither';
+export type GetCurrentTimeError = InvokeCustomMethodError | ValidationError;
+/**
+ * @returns The current time according to the Telegram server time.
+ * @param options - additional options.
+ * @since Mini Apps v6.9
+ */
+export declare const getCurrentTimeFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<GetCurrentTimeError, Date>, true, never>;
+/**
+ * @see getCurrentTimeFp
+ */
+export declare const getCurrentTime: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<GetCurrentTimeError, Date>, true, never>;

package/dist/dts/features/uncategorized/hideKeyboard.d.ts

@@ -0,0 +1,13 @@
+import { PostEventError } from '@tma.js/bridge';
+import * as E from 'fp-ts/Either';
+export type HideKeyboardError = PostEventError;
+/**
+ * Hides the on-screen keyboard, if it is currently visible. Does nothing if the keyboard is
+ * not active.
+ * @since Mini Apps v9.1
+ */
+export declare const hideKeyboardFp: import('../../with-checks/withChecksFp.js').WithChecksFp<() => E.Either<HideKeyboardError, void>, true, never>;
+/**
+ * @see hideKeyboardFp
+ */
+export declare const hideKeyboard: import('../../with-checks/withChecksFp.js').WithChecks<() => E.Either<HideKeyboardError, void>, true, never>;

package/dist/dts/features/uncategorized/readTextFromClipboard.d.ts

@@ -0,0 +1,13 @@
+import { RequestError } from '@tma.js/bridge';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+export type ReadTextFromClipboardError = RequestError;
+/**
+ * Reads a text from the clipboard and returns a `string` or `null`. `null` is returned
+ * in one of the following cases:
+ * - A value in the clipboard is not a text.
+ * - Access to the clipboard is not granted.
+ * @since Mini Apps v6.4
+ */
+export declare const readTextFromClipboardFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(options?: AsyncOptions) => TE.TaskEither<ReadTextFromClipboardError, string | null>, true, never>;
+export declare const readTextFromClipboard: import('../../with-checks/withChecksFp.js').WithChecks<(options?: AsyncOptions) => TE.TaskEither<ReadTextFromClipboardError, string | null>, true, never>;

package/dist/dts/features/uncategorized/retrieveAndroidDeviceData.d.ts

@@ -0,0 +1,6 @@
+import { AndroidDeviceData } from './retrieveAndroidDeviceDataFrom.js';
+/**
+ * Retrieves Android device data from the navigator.userAgent.
+ * @see https://core.telegram.org/bots/webapps#additional-data-in-user-agent
+ */
+export declare function retrieveAndroidDeviceData(): AndroidDeviceData;

package/dist/dts/features/uncategorized/retrieveAndroidDeviceDataFrom.d.ts

@@ -0,0 +1,14 @@
+export interface AndroidDeviceData {
+    appVersion?: string;
+    manufacturer?: string;
+    model?: string;
+    androidVersion?: string;
+    sdkVersion?: number;
+    performanceClass?: 'LOW' | 'AVERAGE' | 'HIGH' | string;
+}
+/**
+ * Retrieves Android device data from the specified User Agent.
+ * @see https://core.telegram.org/bots/webapps#additional-data-in-user-agent
+ * @param userAgent - user agent.
+ */
+export declare function retrieveAndroidDeviceDataFrom(userAgent: string): AndroidDeviceData;

package/dist/dts/features/uncategorized/sendData.d.ts

@@ -0,0 +1,20 @@
+import { PostEventError } from '@tma.js/bridge';
+import { InvalidArgumentsError } from '../../errors.js';
+import * as E from 'fp-ts/Either';
+export type SendDataError = PostEventError | InvalidArgumentsError;
+/**
+ * Sends data to the bot.
+ *
+ * When this method called, a service message sent to the bot containing the data of the length
+ * up to 4096 bytes, and the Mini App closed.
+ *
+ * See the field `web_app_data` in the class [Message](https://core.telegram.org/bots/api#message).
+ *
+ * This method is only available for Mini Apps launched via a Keyboard button.
+ * @param data - data to send to bot.
+ */
+export declare const sendDataFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(data: string) => E.Either<SendDataError, void>, false, never>;
+/**
+ * @see sendDataFp
+ */
+export declare const sendData: import('../../with-checks/withChecksFp.js').WithChecks<(data: string) => E.Either<SendDataError, void>, false, never>;

package/dist/dts/features/uncategorized/shareMessage.d.ts

@@ -0,0 +1,14 @@
+import { RequestError } from '@tma.js/bridge';
+import { ShareMessageError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+import * as TE from 'fp-ts/TaskEither';
+export type ShareMessageFnError = RequestError | ShareMessageError;
+/**
+ * Opens a dialog allowing the user to share a message provided by the bot.
+ * @since Mini Apps v8.0
+ */
+export declare const shareMessageFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(messageId: string, options?: AsyncOptions) => TE.TaskEither<ShareMessageFnError, void>, true, never>;
+/**
+ * @see shareMessageFp
+ */
+export declare const shareMessage: import('../../with-checks/withChecksFp.js').WithChecks<(messageId: string, options?: AsyncOptions) => TE.TaskEither<ShareMessageFnError, void>, true, never>;