@vbotma/sdk 3.1.8

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

@@ -0,0 +1,3 @@
+export { StoragePermission } from './StoragePermission.js';
+export { storagePermission } from './instance.js';
+export type { StoragePermissionOptions, StorageItem, StorageAccessResult, RequestStorageAccessOptions, } from './types.js';

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

@@ -0,0 +1,2 @@
+import { StoragePermission } from './StoragePermission.js';
+export declare const storagePermission: StoragePermission;

package/dist/dts/features/StoragePermission/types.d.ts

@@ -0,0 +1,51 @@
+import { RequestFpFn } from '@vbotma/bridge';
+export interface StoragePermissionOptions {
+    request: RequestFpFn;
+}
+/**
+ * Represents a selected file or folder.
+ */
+export interface StorageItem {
+    name: string;
+    path: string;
+    size?: number;
+    type?: string;
+    content?: string;
+    lastModified?: number;
+}
+/**
+ * Result of storage access request.
+ */
+export interface StorageAccessResult {
+    accessType: 'file' | 'folder';
+    items: StorageItem[];
+}
+/**
+ * Options for requesting storage access.
+ */
+export interface RequestStorageAccessOptions {
+    /**
+     * Type of storage access to request.
+     */
+    accessType: 'file' | 'folder';
+    /**
+     * Allow multiple file selection (only for files).
+     * @default false
+     */
+    multiple?: boolean;
+    /**
+     * MIME types to filter files.
+     */
+    accept?: string[];
+    /**
+     * Maximum file size in bytes.
+     * Files larger than this will be rejected.
+     * @default undefined (no limit)
+     */
+    maxFileSize?: number;
+    /**
+     * Read file content as base64.
+     * @default false
+     */
+    readContent?: boolean;
+}

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

@@ -0,0 +1,62 @@
+import { PostEventError } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { either as E } from 'fp-ts';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithPostEvent } from '../../fn-options/withPostEvent.js';
+import { WithStateRestore } from '../../fn-options/withStateRestore.js';
+import { WithVersion } from '../../fn-options/withVersion.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+export interface SwipeBehaviorState {
+    isVerticalEnabled: boolean;
+}
+export interface SwipeBehaviorOptions extends WithStateRestore<SwipeBehaviorState>, WithVersion, WithPostEvent, SharedFeatureOptions {
+}
+/**
+ * @since Mini Apps v7.7
+ */
+export declare class SwipeBehavior {
+    constructor({ postEvent, storage, isTma, isPageReload, version }: SwipeBehaviorOptions);
+    /**
+     * Signal indicating if the component is supported.
+     */
+    readonly isSupported: Computed<boolean>;
+    /**
+     * Signal indicating if vertical swipes are enabled.
+     */
+    readonly isVerticalEnabled: Computed<boolean>;
+    /**
+     * Signal indicating if the component is currently mounted.
+     */
+    readonly isMounted: Computed<boolean>;
+    /**
+     * Mounts the component restoring its state.
+     * @since Mini Apps v7.7
+     */
+    readonly mountFp: WithChecksFp<() => void, true>;
+    /**
+     * @see mountFp
+     */
+    readonly mount: WithChecks<() => void, true>;
+    /**
+     * Unmounts the component.
+     */
+    readonly unmount: () => void;
+    /**
+     * Disables the closing confirmation dialog.
+     * @since Mini Apps v7.7
+     */
+    readonly disableVerticalFp: WithChecksFp<() => E.Either<PostEventError, void>, true>;
+    /**
+     * @see disableVerticalFp
+     */
+    readonly disableVertical: WithChecks<() => void, true>;
+    /**
+     * Enables the closing confirmation dialog.
+     * @since Mini Apps v7.7
+     */
+    readonly enableVerticalFp: WithChecksFp<() => E.Either<PostEventError, void>, true>;
+    /**
+     * @see enableVerticalFp
+     */
+    readonly enableVertical: WithChecks<() => void, true>;
+}

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

@@ -0,0 +1,2 @@
+export { swipeBehavior } from './instance.js';
+export { type SwipeBehaviorOptions, SwipeBehavior, type SwipeBehaviorState, } from './SwipeBehavior.js';

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

@@ -0,0 +1,2 @@
+import { SwipeBehavior } from './SwipeBehavior.js';
+export declare const swipeBehavior: SwipeBehavior;

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

@@ -0,0 +1,127 @@
+import { EventListener } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { ThemeParams as ThemeParamsType, RGB } from '@vbotma/types';
+import { either as E } from 'fp-ts';
+import { CSSVarsBoundError } from '../../errors.js';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithStateRestore } from '../../fn-options/withStateRestore.js';
+import { MaybeAccessor } from '../../types.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+export type ThemeParamsState = ThemeParamsType;
+export interface ThemeParamsOptions extends WithStateRestore<ThemeParamsState>, SharedFeatureOptions {
+    /**
+     * Removes a theme change listener.
+     * @param listener - a listener to remove.
+     */
+    offChange: (listener: EventListener<'theme_changed'>) => void;
+    /**
+     * Adds a theme change listener.
+     * @returns A function to remove listener.
+     * @param listener - a listener to add.
+     */
+    onChange: (listener: EventListener<'theme_changed'>) => void;
+    /**
+     * Theme parameters initial state.
+     */
+    initialState: MaybeAccessor<ThemeParamsType>;
+}
+export interface ThemeParamsGetCssVarNameFn {
+    /**
+     * @param property - palette key.
+     * @returns Computed complete CSS variable name.
+     */
+    (property: Extract<keyof ThemeParamsType, string>): string;
+}
+export declare class ThemeParams {
+    constructor({ initialState, onChange, offChange, isTma, storage, isPageReload, }: ThemeParamsOptions);
+    /**
+     * @since v6.10
+     */
+    readonly accentTextColor: Computed<RGB | undefined>;
+    readonly bgColor: Computed<RGB | undefined>;
+    readonly buttonColor: Computed<RGB | undefined>;
+    readonly buttonTextColor: Computed<RGB | undefined>;
+    /**
+     * @since v7.10
+     */
+    readonly bottomBarBgColor: Computed<RGB | undefined>;
+    readonly destructiveTextColor: Computed<RGB | undefined>;
+    /**
+     * @since v6.10
+     */
+    readonly headerBgColor: Computed<RGB | undefined>;
+    readonly hintColor: Computed<RGB | undefined>;
+    readonly linkColor: Computed<RGB | undefined>;
+    readonly secondaryBgColor: Computed<RGB | undefined>;
+    /**
+     * @since v6.10
+     */
+    readonly sectionBgColor: Computed<RGB | undefined>;
+    /**
+     * @since v6.10
+     */
+    readonly sectionHeaderTextColor: Computed<RGB | undefined>;
+    /**
+     * @since v7.6
+     */
+    readonly sectionSeparatorColor: Computed<RGB | undefined>;
+    /**
+     * @since v6.10
+     */
+    readonly subtitleTextColor: Computed<RGB | undefined>;
+    readonly textColor: Computed<RGB | undefined>;
+    private readonly _isCssVarsBound;
+    /**
+     * True if CSS variables are currently bound.
+     */
+    readonly isCssVarsBound: Computed<boolean>;
+    /**
+     * Creates CSS variables connected with the current theme parameters.
+     *
+     * By default, created CSS variables names are following the pattern "--tg-theme-{name}", where
+     * {name} is a theme parameters key name converted from snake case to kebab case.
+     *
+     * Default variables:
+     * - `--tg-theme-bg-color`
+     * - `--tg-theme-secondary-text-color`
+     *
+     * Variables are being automatically updated if theme parameters were changed.
+     *
+     * @param getCSSVarName - function, returning complete CSS variable name for the specified
+     * theme parameters key.
+     * @returns Function to stop updating variables.
+     * @throws {CSSVarsBoundError} CSS variables are already bound
+     * @example Using custom CSS vars generator
+     * themeParams.bindCssVars(key => `--my-prefix-${key}`);
+     */
+    readonly bindCssVarsFp: WithChecksFp<(getCSSVarName?: ThemeParamsGetCssVarNameFn) => E.Either<CSSVarsBoundError, VoidFunction>, false>;
+    /**
+     * @see bindCssVarsFp
+     */
+    readonly bindCssVars: WithChecks<(getCSSVarName?: ThemeParamsGetCssVarNameFn) => VoidFunction, false>;
+    /**
+     * Complete component state.
+     */
+    readonly state: Computed<ThemeParamsType>;
+    /**
+     * @returns True if the current color scheme is recognized as dark.
+     * This value is calculated based on the current theme's background color.
+     */
+    readonly isDark: Computed<boolean>;
+    /**
+     * Signal indicating if the component is currently mounted.
+     */
+    readonly isMounted: Computed<boolean>;
+    /**
+     * Mounts the component restoring its state.
+     */
+    readonly mountFp: WithChecksFp<() => E.Either<never, void>, false>;
+    /**
+     * @see mountFp
+     */
+    readonly mount: WithChecks<() => void, false>;
+    /**
+     * Unmounts the component.
+     */
+    readonly unmount: () => void;
+}

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

@@ -0,0 +1,2 @@
+export { themeParams } from './instance.js';
+export { type ThemeParamsOptions, ThemeParams, type ThemeParamsState, type ThemeParamsGetCssVarNameFn, } from './ThemeParams.js';

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

@@ -0,0 +1,2 @@
+import { ThemeParams } from './ThemeParams.js';
+export declare const themeParams: ThemeParams;

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

@@ -0,0 +1,219 @@
+import { SafeAreaInsets, EventListener, RequestError, PostEventError } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { BetterPromise } from 'better-promises';
+import { either as E, taskEither as TE } from 'fp-ts';
+import { CSSVarsBoundError, FullscreenFailedError } from '../../errors.js';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithPostEvent } from '../../fn-options/withPostEvent.js';
+import { WithRequest } from '../../fn-options/withRequest.js';
+import { WithStateRestore } from '../../fn-options/withStateRestore.js';
+import { WithVersion } from '../../fn-options/withVersion.js';
+import { AsyncOptions } from '../../types.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+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('@vbotma/bridge').RetrieveLaunchParamsError, import('@vbotma/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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AsyncOptions } from '../../types.js';
+/**
+ * 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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { SetEmojiStatusError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+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
+ * fn.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 '@vbotma/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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AsyncOptions } from '../../types.js';
+/**
+ * Sends a request to the native VBot 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 '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+import { InvalidArgumentsError } from '../../errors.js';
+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 '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+import { InvalidArgumentsError } from '../../errors.js';
+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 '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+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';