@core-ease/telegram-kit 3.0.1

package/dist/index.d.ts

@@ -0,0 +1,849 @@
+import { W as WebAppKernel, S as SafeAreaInset, P as PopupParams, a as ScanQrPopupParams, H as HomeScreenStatus, D as DownloadFileParams, b as ShareToStoryParams, I as InitParams, O as OpenLinkOptions, c as OpenTelegramLinkOptions, T as TelegramWebView, d as WebApp, A as Accelerometer, e as AnyRecord, B as BackButton, f as BiometricAuthenticateParams, g as BiometricManager, h as BiometricRequestAccessParams, i as BiometricType, j as BottomButton, k as BottomButtonParams, l as BottomButtonPosition, C as CloseOptions, m as CloudStorage, n as ColorScheme, o as DebugBottomBar, p as DefaultColors, q as DeviceOrientation, r as DeviceOrientationStartParams, s as DeviceStorage, E as ErrCallback, t as EventHandler, G as Gyroscope, u as HapticFeedback, v as HapticImpactStyle, w as HapticNotificationType, x as ItemsCallback, L as LocationData, y as LocationManager, M as MotionSensorStartParams, z as PopupButton, F as PopupButtonType, J as SecureStorage, K as SettingsButton, N as ShareToStoryWidgetLink, Q as ThemeManager, R as ThemeParams, U as Utils, V as VoidCallback, X as WebAppChat, Y as WebAppInitDataUnsafe, Z as WebAppUser, _ as EmojiStatusParams, $ as TgWebApp } from './hooks-C5Per70R.js';
+export { a0 as RuntimeMode, a1 as TgPlatform, a2 as WebAppEventType, a3 as useAccelerometer, a4 as useBiometric, a5 as useCloudStorage, a6 as useDeviceOrientation, a7 as useDeviceStorage, a8 as useDownloadFile, a9 as useGyroscope, aa as useHapticFeedback, ab as useHideKeyboard, ac as useHomeScreen, ad as useInitData, ae as useInvokeCustomMethod, af as useIsActive, ag as useLocation, ah as useOrientationLock, ai as useReadTextFromClipboard, aj as useReady, ak as useRequestChat, al as useRequestContact, am as useRequestEmojiStatusAccess, an as useRequestWriteAccess, ao as useSafeArea, ap as useScanQrPopup, aq as useSecureStorage, ar as useSetEmojiStatus, as as useShareMessage, at as useShareToStory, au as useShowAlert, av as useShowConfirm, aw as useShowPopup, ax as useSwitchInlineQuery, ay as useTelegramBackButton, az as useTelegramEvent, aA as useTelegramFullscreen, aB as useTelegramMainButton, aC as useTelegramSecondaryButton, aD as useTelegramSettingsButton, aE as useTelegramStartParam, aF as useTelegramTheme, aG as useTelegramUser, aH as useTelegramViewport, aI as useTelegramWebApp } from './hooks-C5Per70R.js';
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * The original SDK throws plain `Error('SomeName')` objects. We keep the
+ * exact same string names (so existing error-handling code that matches on
+ * `error.message` keeps working) but expose them as a typed enum plus a
+ * small helper so call sites read better than magic strings.
+ */
+declare enum WebAppErrorName {
+    MethodUnsupported = "WebAppMethodUnsupported",
+    DataInvalid = "WebAppDataInvalid",
+    InlineModeDisabled = "WebAppInlineModeDisabled",
+    InlineQueryInvalid = "WebAppInlineQueryInvalid",
+    InlineChooseChatTypesInvalid = "WebAppInlineChooseChatTypesInvalid",
+    InlineChooseChatTypeInvalid = "WebAppInlineChooseChatTypeInvalid",
+    TgUrlInvalid = "WebAppTgUrlInvalid",
+    InvoiceUrlInvalid = "WebAppInvoiceUrlInvalid",
+    InvoiceOpened = "WebAppInvoiceOpened",
+    PopupOpened = "WebAppPopupOpened",
+    PopupParamInvalid = "WebAppPopupParamInvalid",
+    ScanQrPopupOpened = "WebAppScanQrPopupOpened",
+    ScanQrPopupParamInvalid = "WebAppScanQrPopupParamInvalid",
+    WriteAccessRequested = "WebAppWriteAccessRequested",
+    ContactRequested = "WebAppContactRequested",
+    DownloadFilePopupOpened = "WebAppDownloadFilePopupOpened",
+    DownloadFileParamInvalid = "WebAppDownloadFileParamInvalid",
+    MediaUrlInvalid = "WebAppMediaUrlInvalid",
+    ShareToStoryParamInvalid = "WebAppShareToStoryParamInvalid",
+    ShareMessageOpened = "WebAppShareMessageOpened",
+    RequestChatOpened = "WebAppRequestChatOpened",
+    EmojiStatusRequested = "WebAppEmojiStatusRequested",
+    EmojiStatusAccessRequested = "WebAppEmojiStatusAccessRequested",
+    HeaderColorInvalid = "WebAppHeaderColorInvalid",
+    HeaderColorKeyInvalid = "WebAppHeaderColorKeyInvalid",
+    BackgroundColorInvalid = "WebAppBackgroundColorInvalid",
+    BottomBarColorInvalid = "WebAppBottomBarColorInvalid",
+    BottomButtonParamInvalid = "WebAppBottomButtonParamInvalid",
+    HapticImpactStyleInvalid = "WebAppHapticImpactStyleInvalid",
+    HapticNotificationTypeInvalid = "WebAppHapticNotificationTypeInvalid",
+    HapticFeedbackTypeInvalid = "WebAppHapticFeedbackTypeInvalid",
+    BiometricManagerNotInited = "WebAppBiometricManagerNotInited",
+    BiometricManagerBiometricsNotAvailable = "WebAppBiometricManagerBiometricsNotAvailable",
+    BiometricManagerAccessRequested = "WebAppBiometricManagerAccessRequested",
+    BiometricManagerBiometricAccessNotGranted = "WebAppBiometricManagerBiometricAccessNotGranted",
+    BiometricManagerAuthenticationRequested = "WebAppBiometricManagerAuthenticationRequested",
+    BiometricManagerTokenInvalid = "WebAppBiometricManagerTokenInvalid",
+    BiometricManagerTokenUpdateRequested = "WebAppBiometricManagerTokenUpdateRequested",
+    BiometricManagerBiometricsAccessNotRequested = "WebAppBiometricManagerBiometricsAccessNotRequested",
+    BiometricRequestAccessParamInvalid = "WebAppBiometricRequestAccessParamInvalid",
+    LocationManagerNotInited = "WebAppLocationManagerNotInited",
+    LocationManagerLocationNotAvailable = "WebAppLocationManagerLocationNotAvailable",
+    LocationManagerLocationAccessNotRequested = "WebAppLocationManagerLocationAccessNotRequested",
+    CallbackIdGenerateFailed = "WebAppCallbackIdGenerateFailed"
+}
+declare class WebAppError extends Error {
+    constructor(name: WebAppErrorName);
+}
+
+/**
+ * Viewport & window-chrome manager.
+ *
+ * Covers everything related to the app's visible area and window behavior:
+ * viewport height/expansion, safe-area insets, fullscreen state,
+ * orientation lock, the closing confirmation dialog and vertical swipe
+ * toggling. All of it was interleaved with theme code in the original
+ * single closure; split out here since it is a clearly separate concern.
+ */
+
+declare class ViewportManager {
+    private readonly kernel;
+    private viewportHeightPx;
+    private viewportStableHeightPx;
+    private _isExpanded;
+    private _safeAreaInset;
+    private _contentSafeAreaInset;
+    private _isFullscreen;
+    private _isOrientationLocked;
+    private _isClosingConfirmationEnabled;
+    private _isVerticalSwipesEnabled;
+    private lastWindowHeight;
+    constructor(kernel: WebAppKernel);
+    get isExpanded(): boolean;
+    get viewportHeight(): number;
+    get viewportStableHeight(): number;
+    get safeAreaInset(): SafeAreaInset;
+    get contentSafeAreaInset(): SafeAreaInset;
+    get isFullscreen(): boolean;
+    get isOrientationLocked(): boolean;
+    get isClosingConfirmationEnabled(): boolean;
+    get isVerticalSwipesEnabled(): boolean;
+    /** Re-applies the current viewport CSS vars; call after bottom-bar height changes too. */
+    setViewportHeight(data?: {
+        height: number;
+        is_expanded?: boolean;
+        is_state_stable?: boolean;
+    }): void;
+    handleViewportChanged: (_eventType: string, eventData: any) => void;
+    onWindowResize(): void;
+    setSafeAreaInset(data?: Partial<SafeAreaInset>): void;
+    handleSafeAreaChanged: (_eventType: string, eventData: any) => void;
+    setContentSafeAreaInset(data?: Partial<SafeAreaInset>): void;
+    handleContentSafeAreaChanged: (_eventType: string, eventData: any) => void;
+    setClosingConfirmation(needConfirmation: boolean): void;
+    toggleVerticalSwipes(enableSwipes: boolean): void;
+    private setFullscreen;
+    handleFullscreenChanged: (_eventType: string, eventData: any) => void;
+    handleFullscreenFailed: (_eventType: string, eventData: any) => void;
+    requestFullscreen(): void;
+    exitFullscreen(): void;
+    private setOrientationLock;
+    toggleOrientationLock(locked: boolean): void;
+}
+
+/**
+ * `WebApp.showPopup` / `showAlert` / `showConfirm`.
+ */
+
+type PopupCallback = (buttonId: string | null) => void;
+type AlertCallback = () => void;
+type ConfirmCallback = (ok: boolean) => void;
+declare class PopupManager {
+    private readonly kernel;
+    private pending;
+    constructor(kernel: WebAppKernel);
+    private handlePopupClosed;
+    showPopup(params: PopupParams, callback?: PopupCallback): void;
+    showAlert(message: string, callback?: AlertCallback): void;
+    showConfirm(message: string, callback?: ConfirmCallback): void;
+}
+
+/**
+ * `WebApp.showScanQrPopup` / `closeScanQrPopup`.
+ */
+
+/** Return `true` from the callback to close the popup automatically. */
+type ScanQrCallback = (data: string | null) => boolean | void;
+declare class ScanQrManager {
+    private readonly kernel;
+    private pending;
+    constructor(kernel: WebAppKernel);
+    private handleQrTextReceived;
+    private handleScanQrPopupClosed;
+    showScanQrPopup(params: ScanQrPopupParams, callback?: ScanQrCallback): void;
+    closeScanQrPopup(): void;
+}
+
+/**
+ * `WebApp.openInvoice`.
+ */
+
+type InvoiceStatus = 'paid' | 'cancelled' | 'failed' | 'pending';
+type InvoiceCallback = (status: InvoiceStatus) => void;
+declare class InvoiceManager {
+    private readonly kernel;
+    private openInvoices;
+    constructor(kernel: WebAppKernel);
+    private handleInvoiceClosed;
+    openInvoice(url: string, callback?: InvoiceCallback): void;
+}
+
+/**
+ * `WebApp.readTextFromClipboard`.
+ */
+
+type ClipboardCallback = (data: string | null) => void;
+declare class ClipboardManager {
+    private readonly kernel;
+    constructor(kernel: WebAppKernel);
+    private handleClipboardTextReceived;
+    readTextFromClipboard(callback?: ClipboardCallback): void;
+}
+
+/**
+ * `WebApp.requestWriteAccess` / `WebApp.requestContact`.
+ */
+
+type WriteAccessCallback = (granted: boolean) => void;
+type ContactCallback = (sent: boolean, eventPayload: Record<string, any>) => void;
+declare class ContactManager {
+    private readonly kernel;
+    private writeAccessRequested;
+    private contactRequested;
+    constructor(kernel: WebAppKernel);
+    private handleWriteAccessRequested;
+    private handlePhoneRequested;
+    requestWriteAccess(callback?: WriteAccessCallback): void;
+    requestContact(callback?: ContactCallback): void;
+}
+
+/**
+ * `WebApp.addToHomeScreen` / `WebApp.checkHomeScreenStatus`.
+ */
+
+type StatusCallback = (status: HomeScreenStatus) => void;
+declare class HomeScreenManager {
+    private readonly kernel;
+    private statusCallbacks;
+    constructor(kernel: WebAppKernel);
+    private handleAdded;
+    private handleChecked;
+    addToHomeScreen(): void;
+    checkHomeScreenStatus(callback?: StatusCallback): void;
+}
+
+/**
+ * `WebApp.downloadFile`.
+ */
+
+type DownloadCallback = (isDownloading: boolean) => void;
+declare class DownloadFileManager {
+    private readonly kernel;
+    private requested;
+    constructor(kernel: WebAppKernel);
+    private handleFileDownloadRequested;
+    downloadFile(params: DownloadFileParams, callback?: DownloadCallback): void;
+}
+
+/**
+ * Sharing-related surface: `shareToStory`, `shareMessage`, `requestChat`,
+ * `switchInlineQuery`.
+ */
+
+type SentCallback = (sent: boolean) => void;
+declare class SharingManager {
+    private readonly kernel;
+    private shareMessageOpened;
+    private requestChatOpened;
+    constructor(kernel: WebAppKernel);
+    private handlePreparedMessageSent;
+    private handlePreparedMessageFailed;
+    private handleRequestedChatSent;
+    private handleRequestedChatFailed;
+    shareToStory(mediaUrl: string, params?: ShareToStoryParams): void;
+    shareMessage(msgId: string, callback?: SentCallback): void;
+    requestChat(reqId: string, callback?: SentCallback): void;
+    switchInlineQuery(query: string, chooseChatTypes: string[] | undefined, initParams: InitParams): void;
+}
+
+/**
+ * `WebApp.setEmojiStatus` / `WebApp.requestEmojiStatusAccess`.
+ */
+
+type SetStatusCallback = (applied: boolean) => void;
+type AccessCallback = (granted: boolean) => void;
+declare class EmojiStatusManager {
+    private readonly kernel;
+    private setRequested;
+    private accessRequested;
+    constructor(kernel: WebAppKernel);
+    private handleSet;
+    private handleFailed;
+    private handleAccessRequested;
+    setEmojiStatus(customEmojiId: string, params?: {
+        duration?: number;
+    }, callback?: SetStatusCallback): void;
+    requestEmojiStatusAccess(callback?: AccessCallback): void;
+}
+
+/**
+ * `WebApp.openLink` / `WebApp.openTelegramLink` + the iframe `<a href="t.me/...">`
+ * click interception (`linkHandler` in the original script).
+ */
+
+declare class LinkManager {
+    private readonly kernel;
+    constructor(kernel: WebAppKernel);
+    openLink(url: string, options?: OpenLinkOptions): void;
+    openTelegramLink(url: string, options?: OpenTelegramLinkOptions): void;
+    /**
+     * Intercepts clicks on in-page `t.me` links while running inside an
+     * iframe (web.telegram.org) and routes them through `openTelegramLink`
+     * instead of letting the browser navigate directly.
+     */
+    handleDocumentClick: (e: MouseEvent) => void;
+}
+
+/**
+ * `@core-ease/telegram-kit/sdk` - public entry point of the bundled Mini
+ * Apps SDK.
+ *
+ * Everything that actually implements the protocol lives under
+ * `./_internal/` (transport, kernel, theme, ui, features, sensors) and is
+ * considered an implementation detail - import from here, not from
+ * `./_internal/*` directly.
+ *
+ * Calling {@link bootstrapTelegramWebApp} reproduces exactly what the
+ * original `telegram-web-app.js` did when loaded as a `<script>` tag:
+ *   1. Set up `window.Telegram.WebView` (transport + event bus) and
+ *      `window.Telegram.Utils`.
+ *   2. Set up `window.Telegram.WebApp` (the full public API).
+ *
+ * Unlike the very first version of this SDK, bootstrapping is **lazy**
+ * (it does not run automatically just from importing this module). This
+ * lets `core/dev.ts` seed fake init data into session storage *before* the
+ * bridge is constructed, so local/dev-mode "just works" through the exact
+ * same code path as running inside real Telegram - no parallel mock
+ * implementation needed. In practice you never have to think about this:
+ * `getWebApp()` in `core/index.ts` calls {@link bootstrapTelegramWebApp}
+ * for you on first use.
+ */
+
+declare const SDK_NAME = "@core-ease/telegram-kit";
+/**
+ * Runs the SDK bootstrap exactly once (idempotent) and exposes
+ * `window.Telegram.{WebView,Utils,WebApp}`. Safe to call in non-browser
+ * contexts (returns nothing useful but never throws), so it's safe to wire
+ * into SSR code paths.
+ *
+ * This is normally called for you by `getWebApp()` in `core/index.ts` the
+ * first time any @core-ease/telegram-kit function is used - you only need to call it
+ * yourself if you want direct, typed access to the `WebApp`/`TelegramWebView`
+ * instances instead of going through the `core`/`hooks` convenience layer.
+ */
+declare function bootstrapTelegramWebApp(): {
+    webView: TelegramWebView;
+    webApp: WebApp;
+};
+/** True once {@link bootstrapTelegramWebApp} has run at least once. */
+declare function isBootstrapped(): boolean;
+
+declare const index_Accelerometer: typeof Accelerometer;
+declare const index_AnyRecord: typeof AnyRecord;
+declare const index_BackButton: typeof BackButton;
+declare const index_BiometricAuthenticateParams: typeof BiometricAuthenticateParams;
+declare const index_BiometricManager: typeof BiometricManager;
+declare const index_BiometricRequestAccessParams: typeof BiometricRequestAccessParams;
+declare const index_BiometricType: typeof BiometricType;
+declare const index_BottomButton: typeof BottomButton;
+declare const index_BottomButtonParams: typeof BottomButtonParams;
+declare const index_BottomButtonPosition: typeof BottomButtonPosition;
+type index_ClipboardManager = ClipboardManager;
+declare const index_ClipboardManager: typeof ClipboardManager;
+declare const index_CloseOptions: typeof CloseOptions;
+declare const index_CloudStorage: typeof CloudStorage;
+declare const index_ColorScheme: typeof ColorScheme;
+type index_ContactManager = ContactManager;
+declare const index_ContactManager: typeof ContactManager;
+declare const index_DebugBottomBar: typeof DebugBottomBar;
+declare const index_DefaultColors: typeof DefaultColors;
+declare const index_DeviceOrientation: typeof DeviceOrientation;
+declare const index_DeviceOrientationStartParams: typeof DeviceOrientationStartParams;
+declare const index_DeviceStorage: typeof DeviceStorage;
+type index_DownloadFileManager = DownloadFileManager;
+declare const index_DownloadFileManager: typeof DownloadFileManager;
+declare const index_DownloadFileParams: typeof DownloadFileParams;
+type index_EmojiStatusManager = EmojiStatusManager;
+declare const index_EmojiStatusManager: typeof EmojiStatusManager;
+declare const index_ErrCallback: typeof ErrCallback;
+declare const index_EventHandler: typeof EventHandler;
+declare const index_Gyroscope: typeof Gyroscope;
+declare const index_HapticFeedback: typeof HapticFeedback;
+declare const index_HapticImpactStyle: typeof HapticImpactStyle;
+declare const index_HapticNotificationType: typeof HapticNotificationType;
+type index_HomeScreenManager = HomeScreenManager;
+declare const index_HomeScreenManager: typeof HomeScreenManager;
+declare const index_HomeScreenStatus: typeof HomeScreenStatus;
+declare const index_InitParams: typeof InitParams;
+type index_InvoiceManager = InvoiceManager;
+declare const index_InvoiceManager: typeof InvoiceManager;
+declare const index_ItemsCallback: typeof ItemsCallback;
+type index_LinkManager = LinkManager;
+declare const index_LinkManager: typeof LinkManager;
+declare const index_LocationData: typeof LocationData;
+declare const index_LocationManager: typeof LocationManager;
+declare const index_MotionSensorStartParams: typeof MotionSensorStartParams;
+declare const index_OpenLinkOptions: typeof OpenLinkOptions;
+declare const index_OpenTelegramLinkOptions: typeof OpenTelegramLinkOptions;
+declare const index_PopupButton: typeof PopupButton;
+declare const index_PopupButtonType: typeof PopupButtonType;
+type index_PopupManager = PopupManager;
+declare const index_PopupManager: typeof PopupManager;
+declare const index_PopupParams: typeof PopupParams;
+declare const index_SDK_NAME: typeof SDK_NAME;
+declare const index_SafeAreaInset: typeof SafeAreaInset;
+type index_ScanQrManager = ScanQrManager;
+declare const index_ScanQrManager: typeof ScanQrManager;
+declare const index_ScanQrPopupParams: typeof ScanQrPopupParams;
+declare const index_SecureStorage: typeof SecureStorage;
+declare const index_SettingsButton: typeof SettingsButton;
+declare const index_ShareToStoryParams: typeof ShareToStoryParams;
+declare const index_ShareToStoryWidgetLink: typeof ShareToStoryWidgetLink;
+type index_SharingManager = SharingManager;
+declare const index_SharingManager: typeof SharingManager;
+declare const index_TelegramWebView: typeof TelegramWebView;
+declare const index_ThemeManager: typeof ThemeManager;
+declare const index_ThemeParams: typeof ThemeParams;
+declare const index_Utils: typeof Utils;
+type index_ViewportManager = ViewportManager;
+declare const index_ViewportManager: typeof ViewportManager;
+declare const index_VoidCallback: typeof VoidCallback;
+declare const index_WebApp: typeof WebApp;
+declare const index_WebAppChat: typeof WebAppChat;
+type index_WebAppError = WebAppError;
+declare const index_WebAppError: typeof WebAppError;
+type index_WebAppErrorName = WebAppErrorName;
+declare const index_WebAppErrorName: typeof WebAppErrorName;
+declare const index_WebAppInitDataUnsafe: typeof WebAppInitDataUnsafe;
+declare const index_WebAppKernel: typeof WebAppKernel;
+declare const index_WebAppUser: typeof WebAppUser;
+declare const index_bootstrapTelegramWebApp: typeof bootstrapTelegramWebApp;
+declare const index_isBootstrapped: typeof isBootstrapped;
+declare namespace index {
+  export { index_Accelerometer as Accelerometer, index_AnyRecord as AnyRecord, index_BackButton as BackButton, index_BiometricAuthenticateParams as BiometricAuthenticateParams, index_BiometricManager as BiometricManager, index_BiometricRequestAccessParams as BiometricRequestAccessParams, index_BiometricType as BiometricType, index_BottomButton as BottomButton, index_BottomButtonParams as BottomButtonParams, index_BottomButtonPosition as BottomButtonPosition, index_ClipboardManager as ClipboardManager, index_CloseOptions as CloseOptions, index_CloudStorage as CloudStorage, index_ColorScheme as ColorScheme, index_ContactManager as ContactManager, index_DebugBottomBar as DebugBottomBar, index_DefaultColors as DefaultColors, index_DeviceOrientation as DeviceOrientation, index_DeviceOrientationStartParams as DeviceOrientationStartParams, index_DeviceStorage as DeviceStorage, index_DownloadFileManager as DownloadFileManager, index_DownloadFileParams as DownloadFileParams, index_EmojiStatusManager as EmojiStatusManager, index_ErrCallback as ErrCallback, index_EventHandler as EventHandler, index_Gyroscope as Gyroscope, index_HapticFeedback as HapticFeedback, index_HapticImpactStyle as HapticImpactStyle, index_HapticNotificationType as HapticNotificationType, index_HomeScreenManager as HomeScreenManager, index_HomeScreenStatus as HomeScreenStatus, index_InitParams as InitParams, index_InvoiceManager as InvoiceManager, index_ItemsCallback as ItemsCallback, index_LinkManager as LinkManager, index_LocationData as LocationData, index_LocationManager as LocationManager, index_MotionSensorStartParams as MotionSensorStartParams, index_OpenLinkOptions as OpenLinkOptions, index_OpenTelegramLinkOptions as OpenTelegramLinkOptions, index_PopupButton as PopupButton, index_PopupButtonType as PopupButtonType, index_PopupManager as PopupManager, index_PopupParams as PopupParams, index_SDK_NAME as SDK_NAME, index_SafeAreaInset as SafeAreaInset, index_ScanQrManager as ScanQrManager, index_ScanQrPopupParams as ScanQrPopupParams, index_SecureStorage as SecureStorage, index_SettingsButton as SettingsButton, index_ShareToStoryParams as ShareToStoryParams, index_ShareToStoryWidgetLink as ShareToStoryWidgetLink, index_SharingManager as SharingManager, index_TelegramWebView as TelegramWebView, index_ThemeManager as ThemeManager, index_ThemeParams as ThemeParams, index_Utils as Utils, index_ViewportManager as ViewportManager, index_VoidCallback as VoidCallback, index_WebApp as WebApp, index_WebAppChat as WebAppChat, index_WebAppError as WebAppError, index_WebAppErrorName as WebAppErrorName, index_WebAppInitDataUnsafe as WebAppInitDataUnsafe, index_WebAppKernel as WebAppKernel, index_WebAppUser as WebAppUser, index_bootstrapTelegramWebApp as bootstrapTelegramWebApp, index_isBootstrapped as isBootstrapped };
+}
+
+/**
+ * Browser-native fallbacks for `@core-ease/telegram-kit`.
+ *
+ * Every wrapper in `core/index.ts` calls into the real bundled SDK first.
+ * When that isn't possible - the Mini App is opened in a plain browser tab,
+ * or the installed Telegram client is older than a feature needs - these
+ * helpers provide the closest standard Web API equivalent instead of
+ * rejecting the call or spamming the console with "not supported"
+ * warnings. Where no meaningful browser equivalent exists (biometrics,
+ * emoji status, Telegram-account actions, ...) the wrapper still resolves
+ * predictably (`false`/`null`/`[]`) instead of throwing.
+ */
+
+/** Swallows synchronous throws from fire-and-forget SDK calls (e.g. hard version gates). */
+declare function safeInvoke(fn: () => void): void;
+
+/** Returns the bundled SDK's `WebApp` instance directly (never reads `window.Telegram`). */
+declare function getWebApp(): WebApp | null;
+/**
+ * `true` once real Telegram init data has been observed - i.e. the Mini
+ * App was actually opened from inside Telegram, or `installDevMode()`
+ * seeded matching fake data for local testing.
+ */
+declare function isInTelegram(): boolean;
+declare function isVersionAtLeast(version: string): boolean;
+declare function getRawUserData(): WebAppUser | null;
+declare function getUserDisplayName(user?: WebAppUser): string;
+declare function getUserIdentifier(user?: WebAppUser): string;
+declare function getUserAvatarUrl(user?: WebAppUser, fallback?: string): string;
+declare function getUserInfoWithAvatar(): {
+    user: WebAppUser | undefined;
+    avatarUrl: string;
+    displayName: string;
+    identifier: string;
+};
+declare function openExternalLink(url: string, tryInstantView?: boolean): void;
+declare function openTelegramLink(url: string): void;
+/** No meaningful browser fallback exists for Telegram Payments; rejects clearly instead of hanging. */
+declare function openInvoice(url: string): Promise<'paid' | 'cancelled' | 'failed' | 'pending'>;
+declare function switchInlineQuery(query: string, chooseChatTypes?: Array<'users' | 'bots' | 'groups' | 'channels'>): void;
+declare function hideKeyboard(): void;
+declare function getTheme(): {
+    colorScheme: ColorScheme;
+    themeParams: ThemeParams;
+};
+declare function getViewport(): {
+    height: number;
+    stableHeight: number;
+    isExpanded: boolean;
+};
+declare function expand(): void;
+declare function ready(): void;
+declare function close(): void;
+/** Fullscreen API fallback outside Telegram / older clients. */
+declare const fullscreen: {
+    enter: () => Promise<boolean>;
+    exit: () => Promise<boolean>;
+};
+/** Screen Orientation API fallback outside Telegram / older clients. */
+declare const orientation: {
+    lock: () => Promise<boolean>;
+    unlock: () => Promise<boolean>;
+};
+declare function enableClosingConfirmation(): void;
+declare function disableClosingConfirmation(): void;
+declare function enableVerticalSwipes(): void;
+declare function disableVerticalSwipes(): void;
+declare function setHeaderColor(color: string): void;
+declare function setBackgroundColor(color: string): void;
+declare function setBottomBarColor(color: string): void;
+/** No meaningful browser equivalent (this adds a Telegram Mini App shortcut, specifically) - safely no-ops outside Telegram. */
+declare function addToHomeScreen(): void;
+declare function checkHomeScreenStatus(): Promise<'unsupported' | 'unknown' | 'added' | 'missed'>;
+declare const haptic: {
+    light: () => void | HapticFeedback;
+    medium: () => void | HapticFeedback;
+    heavy: () => void | HapticFeedback;
+    rigid: () => void | HapticFeedback;
+    soft: () => void | HapticFeedback;
+    success: () => void | HapticFeedback;
+    warning: () => void | HapticFeedback;
+    error: () => void | HapticFeedback;
+    selection: () => void | HapticFeedback;
+};
+declare const cloudStorage: {
+    setItem: (key: string, value: string) => Promise<boolean>;
+    getItem: (key: string) => Promise<string | undefined>;
+    getItems: (keys: string[]) => Promise<Record<string, string>>;
+    removeItem: (key: string) => Promise<boolean>;
+    removeItems: (keys: string[]) => Promise<boolean>;
+    getKeys: () => Promise<string[]>;
+};
+declare const deviceStorage: {
+    setItem: (key: string, value: string) => Promise<boolean>;
+    getItem: (key: string) => Promise<string | undefined>;
+    removeItem: (key: string) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+};
+declare const secureStorage: {
+    setItem: (key: string, value: string) => Promise<boolean>;
+    getItem: (key: string) => Promise<{
+        value: string | null | undefined;
+        canRestore: boolean;
+    }>;
+    removeItem: (key: string) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    restoreItem: (key: string) => Promise<string | undefined>;
+};
+declare const dialog: {
+    alert: (message: string) => Promise<void>;
+    confirm: (message: string) => Promise<boolean>;
+    popup: (params: PopupParams) => Promise<string | null>;
+    prompt: (message: string, defaultValue?: string) => Promise<string | null>;
+};
+declare function readClipboard(): Promise<string | null>;
+declare function scanQr(text?: string): Promise<string | null>;
+declare function shareToStory(mediaUrl: string, params?: ShareToStoryParams): void;
+declare function shareMessage(msgId: string): Promise<boolean>;
+declare function downloadFile(params: DownloadFileParams): Promise<boolean>;
+declare function setEmojiStatus(customEmojiId: string, params?: EmojiStatusParams): Promise<boolean>;
+declare function requestEmojiStatusAccess(): Promise<boolean>;
+declare function requestWriteAccess(): Promise<boolean>;
+declare function requestContact(): Promise<boolean>;
+/**
+ * Opens Telegram's native chat-request dialog for a chat request you
+ * already created server-side, identified by `reqId`. Requires Bot API
+ * 9.6+. No browser fallback exists for this Telegram-account action.
+ */
+declare function requestChat(reqId: string): Promise<boolean>;
+/** No fallback: this calls your own bot's server-side logic, which only exists via the real Telegram client. */
+declare function invokeCustomMethod(method: string, params?: object): Promise<unknown>;
+declare const biometric: {
+    init: () => Promise<void>;
+    requestAccess: (reason?: string) => Promise<boolean>;
+    authenticate: (reason?: string) => Promise<{
+        authenticated: boolean;
+        token?: string;
+    }>;
+    updateBiometricToken: (token: string) => Promise<boolean>;
+    openSettings: () => void;
+};
+declare const location: {
+    init: () => Promise<void>;
+    getLocation: () => Promise<LocationData | null>;
+    openSettings: () => void;
+};
+
+interface ChatAdministratorRights {
+    is_anonymous?: boolean;
+    can_manage_chat?: boolean;
+    can_delete_messages?: boolean;
+    can_manage_video_chats?: boolean;
+    can_restrict_members?: boolean;
+    can_promote_members?: boolean;
+    can_change_info?: boolean;
+    can_invite_users?: boolean;
+    can_post_stories?: boolean;
+    can_edit_stories?: boolean;
+    can_delete_stories?: boolean;
+    can_post_messages?: boolean;
+    can_edit_messages?: boolean;
+    can_pin_messages?: boolean;
+    can_manage_topics?: boolean;
+}
+interface InlineKeyboardMarkup {
+    inline_keyboard: InlineKeyboardButton[][];
+}
+interface InlineKeyboardButton {
+    text: string;
+    url?: string;
+    callback_data?: string;
+    web_app?: WebAppInfo;
+    login_url?: LoginUrl;
+    switch_inline_query?: string;
+    switch_inline_query_current_chat?: string;
+    switch_inline_query_chosen_chat?: SwitchInlineQueryChosenChat;
+    copy_text?: CopyTextButton;
+    callback_game?: CallbackGame;
+    pay?: boolean;
+}
+interface WebAppInfo {
+    url: string;
+}
+interface LoginUrl {
+    url: string;
+    forward_text?: string;
+    bot_username?: string;
+    request_write_access?: boolean;
+}
+interface SwitchInlineQueryChosenChat {
+    query?: string;
+    allow_user_chats?: boolean;
+    allow_bot_chats?: boolean;
+    allow_group_chats?: boolean;
+    allow_channel_chats?: boolean;
+}
+interface CopyTextButton {
+    text: string;
+}
+interface CallbackGame {
+}
+interface ReplyKeyboardMarkup {
+    keyboard: KeyboardButton[][];
+    is_persistent?: boolean;
+    resize_keyboard?: boolean;
+    one_time_keyboard?: boolean;
+    input_field_placeholder?: string;
+    selective?: boolean;
+}
+interface KeyboardButton {
+    text: string;
+    request_users?: KeyboardButtonRequestUsers;
+    request_chat?: KeyboardButtonRequestChat;
+    request_contact?: boolean;
+    request_location?: boolean;
+    request_poll?: KeyboardButtonPollType;
+    web_app?: WebAppInfo;
+}
+interface KeyboardButtonRequestUsers {
+    request_id: number;
+    user_is_bot?: boolean;
+    user_is_premium?: boolean;
+    max_quantity?: number;
+    request_name?: boolean;
+    request_username?: boolean;
+    request_photo?: boolean;
+}
+interface KeyboardButtonRequestChat {
+    request_id: number;
+    chat_is_channel: boolean;
+    chat_is_forum?: boolean;
+    chat_has_username?: boolean;
+    chat_is_created?: boolean;
+    user_administrator_rights?: ChatAdministratorRights;
+    bot_administrator_rights?: ChatAdministratorRights;
+    bot_is_member?: boolean;
+    request_title?: boolean;
+    request_username?: boolean;
+    request_photo?: boolean;
+}
+interface KeyboardButtonPollType {
+    type?: 'quiz' | 'regular';
+}
+interface ReplyKeyboardRemove {
+    remove_keyboard: true;
+    selective?: boolean;
+}
+interface ForceReply {
+    force_reply: true;
+    input_field_placeholder?: string;
+    selective?: boolean;
+}
+
+interface TelegramContextValue {
+    ready: boolean;
+    inTelegram: boolean;
+    isDevBypass: boolean;
+    webApp: TgWebApp | null;
+    user: WebAppUser | null;
+    colorScheme: 'light' | 'dark';
+    startParam: string | null;
+}
+interface TelegramProviderOptions {
+    onUserReady?: (user: WebAppUser) => void;
+    onReady?: (wa: TgWebApp) => void;
+    loadingComponent?: ReactNode;
+    notInTelegramComponent?: ReactNode;
+    allowOutsideTelegram?: boolean;
+    autoExpand?: boolean;
+    autoDisableVerticalSwipes?: boolean;
+    autoEnableClosingConfirmation?: boolean;
+    headerColor?: string;
+    backgroundColor?: string;
+    bottomBarColor?: string;
+}
+declare function useTelegram(): TelegramContextValue;
+declare function TelegramProvider({ children, options, }: {
+    children: ReactNode;
+    options?: TelegramProviderOptions;
+}): React.JSX.Element;
+
+declare class TelegramFormattedText {
+    readonly raw: string;
+    constructor(raw: string);
+    toString(): string;
+}
+type TextPart = string | TelegramFormattedText;
+declare function escapeMarkdownV2(text: string): string;
+declare function escapeMarkdownV2Code(text: string): string;
+declare function escapeMarkdownV2LinkUrl(url: string): string;
+declare function escapeHTML(text: string): string;
+declare function escapeHTMLAttribute(text: string): string;
+declare const md: {
+    escape: typeof escapeMarkdownV2;
+    escapeCode: typeof escapeMarkdownV2Code;
+    escapeLinkUrl: typeof escapeMarkdownV2LinkUrl;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (raw: string) => TelegramFormattedText;
+};
+declare const html: {
+    escape: typeof escapeHTML;
+    escapeAttribute: typeof escapeHTMLAttribute;
+    text: (...parts: TextPart[]) => TelegramFormattedText;
+    bold: (...parts: TextPart[]) => TelegramFormattedText;
+    italic: (...parts: TextPart[]) => TelegramFormattedText;
+    underline: (...parts: TextPart[]) => TelegramFormattedText;
+    strikethrough: (...parts: TextPart[]) => TelegramFormattedText;
+    spoiler: (...parts: TextPart[]) => TelegramFormattedText;
+    code: (text: string) => TelegramFormattedText;
+    pre: (text: string, language?: string) => TelegramFormattedText;
+    link: (url: string, ...parts: TextPart[]) => TelegramFormattedText;
+    mentionUser: (userId: number, ...parts: TextPart[]) => TelegramFormattedText;
+    blockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    expandableBlockquote: (...parts: TextPart[]) => TelegramFormattedText;
+    customEmoji: (emojiId: string, fallbackEmoji: string) => TelegramFormattedText;
+    raw: (rawHtml: string) => TelegramFormattedText;
+};
+declare const TELEGRAM_TEXT_LIMITS: {
+    readonly MESSAGE: 4096;
+    readonly CAPTION: 1024;
+    readonly BUTTON_TEXT: 64;
+    readonly CALLBACK_DATA: 64;
+    readonly START_PARAMETER: 64;
+    readonly BOT_DESCRIPTION: 512;
+    readonly BOT_SHORT_DESCRIPTION: 120;
+    readonly CHAT_TITLE: 128;
+    readonly POLL_QUESTION: 300;
+    readonly POLL_OPTION: 100;
+};
+declare function truncateText(text: string, maxLength: number, ellipsis?: string): string;
+
+declare function isValidStartParam(param: string): boolean;
+declare function encodeStartParam(value: string): string;
+declare function decodeStartParam(param: string): string;
+interface StartParamInput {
+    startParam?: string;
+    data?: string;
+}
+interface BuildStartLinkOptions extends StartParamInput {
+    botUsername: string;
+}
+declare function buildStartLink(options: BuildStartLinkOptions): string;
+interface BuildStartAppLinkOptions extends StartParamInput {
+    botUsername: string;
+    appName?: string;
+    mode?: 'compact' | 'fullscreen';
+}
+declare function buildStartAppLink(options: BuildStartAppLinkOptions): string;
+interface BuildShareLinkOptions {
+    url: string;
+    text?: string;
+}
+declare function buildShareLink(options: BuildShareLinkOptions): string;
+type ParsedTelegramLink = {
+    type: 'profile';
+    username: string;
+} | {
+    type: 'bot-start';
+    username: string;
+    startParam: string;
+} | {
+    type: 'mini-app';
+    username: string;
+    appName?: string;
+    startParam?: string;
+    mode?: string;
+} | {
+    type: 'join-chat';
+    inviteHash: string;
+} | {
+    type: 'private-channel-post';
+    internalChatId: string;
+    messageId: number;
+} | {
+    type: 'share';
+    url?: string;
+    text?: string;
+} | {
+    type: 'unknown';
+    url: string;
+};
+declare function parseTelegramLink(link: string): ParsedTelegramLink;
+
+declare class InlineKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(text: string, callbackData: string): this;
+    url(text: string, url: string): this;
+    webApp(text: string, url: string): this;
+    login(text: string, loginUrl: string | LoginUrl): this;
+    switchInline(text: string, query?: string): this;
+    switchInlineCurrentChat(text: string, query?: string): this;
+    switchInlineChosenChat(text: string, query?: SwitchInlineQueryChosenChat): this;
+    copyText(text: string, copyText: string | CopyTextButton): this;
+    pay(text?: string): this;
+    callbackGame(text: string): this;
+    button(button: InlineKeyboardButton): this;
+    row(): this;
+    static columns(buttons: InlineKeyboardButton[], perRow: number): InlineKeyboardBuilder;
+    build(): InlineKeyboardMarkup;
+}
+interface ReplyKeyboardBuildOptions {
+    resize?: boolean;
+    oneTime?: boolean;
+    selective?: boolean;
+    placeholder?: string;
+    persistent?: boolean;
+}
+declare class ReplyKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(label: string): this;
+    requestContact(label: string): this;
+    requestLocation(label: string): this;
+    requestPoll(label: string, type?: KeyboardButtonPollType['type']): this;
+    webApp(label: string, url: string): this;
+    requestUsers(label: string, params: KeyboardButtonRequestUsers): this;
+    requestChat(label: string, params: KeyboardButtonRequestChat): this;
+    button(button: KeyboardButton): this;
+    row(): this;
+    build(options?: ReplyKeyboardBuildOptions): ReplyKeyboardMarkup;
+}
+declare function removeKeyboard(selective?: boolean): ReplyKeyboardRemove;
+declare function forceReply(options?: {
+    placeholder?: string;
+    selective?: boolean;
+}): ForceReply;
+
+export { type BuildShareLinkOptions, type BuildStartAppLinkOptions, type BuildStartLinkOptions, ColorScheme, SafeAreaInset as ContentSafeAreaInset, DownloadFileParams, EmojiStatusParams, HomeScreenStatus, InlineKeyboardBuilder, LocationData, type ParsedTelegramLink, PopupButton, PopupParams, type ReplyKeyboardBuildOptions, ReplyKeyboardBuilder, SafeAreaInset, ScanQrPopupParams, ShareToStoryParams as StoryShareParams, ShareToStoryWidgetLink as StoryWidgetLink, TELEGRAM_TEXT_LIMITS, type TelegramContextValue, TelegramFormattedText, TelegramProvider, type TelegramProviderOptions, ThemeParams as TgThemeParams, WebAppUser as TgUser, TgWebApp, WebAppChat as TgWebAppChat, WebAppInitDataUnsafe as WebAppInitData, addToHomeScreen, biometric, bootstrapTelegramWebApp, buildShareLink, buildStartAppLink, buildStartLink, checkHomeScreenStatus, close, cloudStorage, decodeStartParam, deviceStorage, dialog, disableClosingConfirmation, disableVerticalSwipes, downloadFile, enableClosingConfirmation, enableVerticalSwipes, encodeStartParam, escapeHTML, escapeHTMLAttribute, escapeMarkdownV2, escapeMarkdownV2Code, escapeMarkdownV2LinkUrl, expand, forceReply, fullscreen, getRawUserData, getTheme, getUserAvatarUrl, getUserDisplayName, getUserIdentifier, getUserInfoWithAvatar, getViewport, getWebApp, haptic, hideKeyboard, html, invokeCustomMethod, isInTelegram, isValidStartParam, isVersionAtLeast, location, md, openExternalLink, openInvoice, openTelegramLink, orientation, parseTelegramLink, readClipboard, ready, removeKeyboard, requestChat, requestContact, requestEmojiStatusAccess, requestWriteAccess, safeInvoke, scanQr, index as sdk, secureStorage, setBackgroundColor, setBottomBarColor, setEmojiStatus, setHeaderColor, shareMessage, shareToStory, switchInlineQuery, truncateText, useTelegram };