@vbotma/sdk 3.1.8

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

@@ -0,0 +1,59 @@
+import { BetterTaskEitherError } from '@vbotma/toolkit';
+import { taskEither as TE } from 'fp-ts';
+import { AccessDeniedError, ValidationError } from '../../errors.js';
+import { InvokeCustomMethodError } from '../../fn-options/withInvokeCustomMethod.js';
+import { AsyncOptions } from '../../types.js';
+/**
+ * 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 VBot 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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AsyncOptions } from '../../types.js';
+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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AsyncOptions } from '../../types.js';
+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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AccessDeniedError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+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
+ * fn.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 { taskEither as TE } from 'fp-ts';
+import { ValidationError } from '../../errors.js';
+import { InvokeCustomMethodError } from '../../fn-options/withInvokeCustomMethod.js';
+import { AsyncOptions } from '../../types.js';
+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 '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { AsyncOptions } from '../../types.js';
+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 '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+import { InvalidArgumentsError } from '../../errors.js';
+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 '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { ShareMessageError } from '../../errors.js';
+import { AsyncOptions } from '../../types.js';
+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>;

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

@@ -0,0 +1,50 @@
+import { PostEventError } from '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+export interface ShareStoryOptions {
+    /**
+     * The caption to be added to the media.
+     * 0-200 characters for regular users and 0-2048 characters for premium subscribers.
+     * @see https://telegram.org/faq_premium#telegram-premium
+     */
+    text?: string;
+    /**
+     * An object that describes a widget link to be included in the story.
+     * Note that only premium subscribers can post stories with links.
+     * @see https://telegram.org/faq_premium#telegram-premium
+     */
+    widgetLink?: {
+        /**
+         * The URL to be included in the story.
+         */
+        url: string;
+        /**
+         * The name to be displayed for the widget link, 0-48 characters.
+         */
+        name?: string;
+    };
+}
+export type ShareStoryError = PostEventError;
+/**
+ * Opens the native story editor.
+ * @since Mini Apps v7.8
+ * @example
+ * fn.pipe(
+ *   shareStory('https://example.com/background.png', {
+ *     text: 'Look at this cool group!',
+ *     widgetLink: {
+ *       url: 'https://t.me/heyqbnk',
+ *       name: 'Vlad\'s community',
+ *     },
+ *   }),
+ *   TE.match(error => {
+ *     console.error('Something went wrong', error);
+ *   }, () => {
+ *     console.log('Call was successful');
+ *   }),
+ * );
+ */
+export declare const shareStoryFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(mediaUrl: string, options?: ShareStoryOptions) => E.Either<ShareStoryError, void>, true, never>;
+/**
+ * @see shareStoryFp
+ */
+export declare const shareStory: import('../../with-checks/withChecksFp.js').WithChecks<(mediaUrl: string, options?: ShareStoryOptions) => E.Either<ShareStoryError, void>, true, never>;

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

@@ -0,0 +1,28 @@
+import { PostEventError, SwitchInlineQueryChatType } from '@vbotma/bridge';
+import { either as E } from 'fp-ts';
+export type SwitchInlineQueryError = PostEventError;
+/**
+ * Inserts the bot's username and the specified inline query in the current chat's input field.
+ * Query may be empty, in which case only the bot's username will be inserted. The client prompts
+ * the user to choose a specific chat, then opens that chat and inserts the bot's username and
+ * the specified inline query in the input field.
+ * @param query - text which should be inserted in the input after the current bot name. Max
+ * length is 256 symbols.
+ * @param chatTypes - List of chat types which could be chosen to send the message. Could be an
+ * empty list.
+ * @since Mini Apps v6.7
+ * @example
+ * fn.pipe(
+ *   switchInlineQuery('my query goes here', ['users']),
+ *   E.match(error => {
+ *     console.error('Something went wrong', error);
+ *   }, () => {
+ *     console.log('Call was successful');
+ *   }),
+ * );
+ */
+export declare const switchInlineQueryFp: import('../../with-checks/withChecksFp.js').WithChecksFp<(query: string, chatTypes?: SwitchInlineQueryChatType[]) => E.Either<SwitchInlineQueryError, void>, true, never>;
+/**
+ * @see switchInlineQueryFp
+ */
+export declare const switchInlineQuery: import('../../with-checks/withChecksFp.js').WithChecks<(query: string, chatTypes?: SwitchInlineQueryChatType[]) => E.Either<SwitchInlineQueryError, void>, true, never>;

package/dist/dts/fn-options/bottomButtonOptions.d.ts

@@ -0,0 +1,11 @@
+import { EventName } from '@vbotma/bridge';
+export declare function bottomButtonOptions<S, D>(storageName: string, trackedClickEvent: EventName, defaults: D): {
+    defaults: D;
+    onClick(listener: VoidFunction, once?: boolean): VoidFunction;
+    offClick(listener: VoidFunction, once?: boolean): void;
+    isTma: import('../types.js').MaybeAccessor<boolean>;
+    postEvent: import('@vbotma/bridge').PostEventFpFn;
+    version: import('../types.js').MaybeAccessor<import('@vbotma/types').Version>;
+    storage: import('../helpers/component-storage.js').ComponentStorage<S>;
+    isPageReload: import('../types.js').MaybeAccessor<boolean>;
+};

package/dist/dts/fn-options/buttonOptions.d.ts

@@ -0,0 +1,10 @@
+import { EventName } from '@vbotma/bridge';
+export declare function buttonOptions<S>(storageName: string, trackedClickEvent: EventName): {
+    onClick(listener: VoidFunction, once?: boolean): VoidFunction;
+    offClick(listener: VoidFunction, once?: boolean): void;
+    isTma: import('../types.js').MaybeAccessor<boolean>;
+    postEvent: import('@vbotma/bridge').PostEventFpFn;
+    version: import('../types.js').MaybeAccessor<import('@vbotma/types').Version>;
+    storage: import('../helpers/component-storage.js').ComponentStorage<S>;
+    isPageReload: import('../types.js').MaybeAccessor<boolean>;
+};

package/dist/dts/fn-options/createFnOption.d.ts

@@ -0,0 +1,2 @@
+import { MaybeAccessor } from '../types.js';
+export declare function createFnOption<T>(mix: MaybeAccessor<T>): <O extends object>(obj: O) => O & T;

package/dist/dts/fn-options/sharedFeatureOptions.d.ts

@@ -0,0 +1,8 @@
+import { MaybeAccessor } from '../types.js';
+export interface SharedFeatureOptions {
+    /**
+     * True if the current environment is VBot Mini Apps.
+     */
+    isTma: MaybeAccessor<boolean>;
+}
+export declare function sharedFeatureOptions(): SharedFeatureOptions;

package/dist/dts/fn-options/withCreateRequestId.d.ts

@@ -0,0 +1,7 @@
+export interface WithCreateRequestId {
+    /**
+     * A function generating a request identifier.
+     */
+    createRequestId: () => string;
+}
+export declare const withCreateRequestId: <O extends object>(obj: O) => O & WithCreateRequestId;

package/dist/dts/fn-options/withInvokeCustomMethod.d.ts

@@ -0,0 +1,11 @@
+import { CustomMethodParams, CustomMethodName, InvokeCustomMethodError, InvokeCustomMethodFpOptions, RequestError } from '@vbotma/bridge';
+import type * as TE from 'fp-ts/TaskEither';
+export type { InvokeCustomMethodError };
+export interface InvokeCustomMethodNoRequestIdFn {
+    <M extends CustomMethodName>(this: void, method: M, params: CustomMethodParams<M>, options?: InvokeCustomMethodFpOptions): TE.TaskEither<InvokeCustomMethodError, unknown>;
+    (this: void, method: string, params: object, options?: InvokeCustomMethodFpOptions): TE.TaskEither<RequestError, unknown>;
+}
+export interface WithInvokeCustomMethod {
+    invokeCustomMethod: InvokeCustomMethodNoRequestIdFn;
+}
+export declare const withInvokeCustomMethod: <O extends object>(obj: O) => O & WithInvokeCustomMethod;

package/dist/dts/fn-options/withPostEvent.d.ts

@@ -0,0 +1,8 @@
+import { PostEventFpFn } from '@vbotma/bridge';
+export interface WithPostEvent {
+    /**
+     * A postEvent function to use to call Mini Apps methods.
+     */
+    postEvent: PostEventFpFn;
+}
+export declare const withPostEvent: <O extends object>(obj: O) => O & WithPostEvent;

package/dist/dts/fn-options/withRequest.d.ts

@@ -0,0 +1,8 @@
+import { Request2FpFn } from '@vbotma/bridge';
+export interface WithRequest {
+    /**
+     * A request function to use to call Mini Apps methods.
+     */
+    request: Request2FpFn;
+}
+export declare const withRequest: <O extends object>(obj: O) => O & WithRequest;

package/dist/dts/fn-options/withStateRestore.d.ts

@@ -0,0 +1,13 @@
+import { ComponentStorage } from '../helpers/component-storage.js';
+import { MaybeAccessor } from '../types.js';
+export interface WithStateRestore<T> {
+    /**
+     * A storage the component could use to store its data.
+     */
+    storage: ComponentStorage<T>;
+    /**
+     * True if the current page is reloaded.
+     */
+    isPageReload: MaybeAccessor<boolean>;
+}
+export declare function withStateRestore<S>(storageName: string): <O extends object>(obj: O) => O & WithStateRestore<S>;

package/dist/dts/fn-options/withVersion.d.ts

@@ -0,0 +1,9 @@
+import { Version } from '@vbotma/types';
+import { MaybeAccessor } from '../types.js';
+export interface WithVersion {
+    /**
+     * The currently supported VBot Mini Apps version by the VBot client.
+     */
+    version: MaybeAccessor<Version>;
+}
+export declare const withVersion: <O extends object>(obj: O) => O & WithVersion;

package/dist/dts/globals/createRequestId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns A new request identifier.
+ */
+export declare function createRequestId(): string;

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

@@ -0,0 +1,16 @@
+import { RequestError, CustomMethodName, CustomMethodParams, InvokeCustomMethodOptions } from '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+/**
+ * Invokes known custom method. Returns method execution result.
+ * @param method - method name.
+ * @param params - method parameters.
+ * @param options - additional options.
+ */
+export declare function invokeCustomMethod<M extends CustomMethodName>(method: M, params: CustomMethodParams<M>, options?: InvokeCustomMethodOptions): TE.TaskEither<RequestError, unknown>;
+/**
+ * Invokes unknown custom method. Returns method execution result.
+ * @param method - method name.
+ * @param params - method parameters.
+ * @param options - additional options.
+ */
+export declare function invokeCustomMethod(method: string, params: object, options?: InvokeCustomMethodOptions): TE.TaskEither<RequestError, unknown>;

package/dist/dts/globals/isInlineMode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * True if the application is launched in inline mode.
+ */
+export declare const isInlineMode: import('@vbotma/signals').Signal<boolean>;

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

@@ -0,0 +1,4 @@
+import { postEventFp as _postEventFp, PostEventFpFn, PostEventFn } from '@vbotma/bridge';
+export declare const postEventFpSignal: import('@vbotma/signals').Signal<typeof _postEventFp>;
+export declare const postEventFp: PostEventFpFn;
+export declare const postEvent: PostEventFn;

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

@@ -0,0 +1,13 @@
+import { RequestFpFn, RequestFn, Request2FpFn, Request2Fn } from '@vbotma/bridge';
+/**
+ * @deprecated To be removed in the next major update. Use `request2fp` instead, it provides
+ * a proper way of handling multiple events.
+ */
+export declare const requestFp: RequestFpFn;
+export declare const request2Fp: Request2FpFn;
+/**
+ * @deprecated To be removed in the next major update. Use `request` instead, it provides
+ * a proper way of handling multiple events.
+ */
+export declare const request: RequestFn;
+export declare const request2: Request2Fn;

package/dist/dts/globals/resetGlobals.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Resets all bridge globals and locally created signals.
+ */
+export declare function resetGlobals(): void;

package/dist/dts/globals/signals-registry.d.ts

@@ -0,0 +1,39 @@
+import { Computed, Signal, SignalOptions } from '@vbotma/signals';
+export type SignalsTuple<T> = [Signal<T>, Computed<T>];
+/**
+ * Creates a new signal with the initial value.
+ * @param initialValue - the initial value.
+ * @param options - additional options.
+ */
+export declare function createSignal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Creates a new signal without the initial value.
+ * @param initialValue - the initial value.
+ * @param options - additional options.
+ */
+export declare function createSignal<T>(initialValue?: T, options?: SignalOptions<T | undefined>): Signal<T | undefined>;
+/**
+ * Creates a signal, which wil be automatically updated if some of its dependant signals were
+ * modified.
+ * @param fn - computation function.
+ * @param options - additional functions.
+ */
+export declare function createComputed<T>(fn: (prev?: T) => T, options?: SignalOptions<T>): Computed<T>;
+/**
+ * Resets all signals states.
+ */
+export declare function resetSignals(): void;
+/**
+ * @returns A tuple, containing a manual and computed signals. The computed signal is based on
+ * the manual one.
+ * @param initialValue - the initial value.
+ * @param options - additional options.
+ */
+export declare function createSignalsTuple<T>(initialValue: T, options?: SignalOptions<T>): SignalsTuple<T>;
+/**
+ * @returns A tuple, containing a manual and computed signals. The computed signal is based on
+ * the manual one.
+ * @param initialValue - an initial value.
+ * @param options - additional options.
+ */
+export declare function createSignalsTuple<T>(initialValue?: T, options?: SignalOptions<T | undefined>): SignalsTuple<T | undefined>;

package/dist/dts/globals/themeParams.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Mini application's theme parameters.
+ */
+export declare const themeParams: import('@vbotma/signals').Signal<Partial<Record<string, `#${string}`>>>;

package/dist/dts/globals/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The current Mini Apps version.
+ */
+export declare const version: import('@vbotma/signals').Signal<string>;

package/dist/dts/helpers/access.d.ts

@@ -0,0 +1,2 @@
+import { MaybeAccessor } from '../types.js';
+export declare function access<T>(value: MaybeAccessor<T>): T;

package/dist/dts/helpers/component-storage.d.ts

@@ -0,0 +1,9 @@
+export interface ComponentStorage<T> {
+    get: () => T | undefined;
+    set: (value: T) => void;
+}
+/**
+ * Creates a new sessionStorage-based component storage.
+ * @param key - session storage key to use.
+ */
+export declare function createComponentSessionStorage<T>(key: string): ComponentStorage<T>;

package/dist/dts/helpers/createIsSupportedSignal.d.ts

@@ -0,0 +1,5 @@
+import { MethodName } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { Version } from '@vbotma/types';
+import { MaybeAccessor } from '../types.js';
+export declare function createIsSupportedSignal(method: MethodName, version: MaybeAccessor<Version>): Computed<boolean>;

package/dist/dts/helpers/css-vars.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sets CSS variable globally.
+ * @param name - variable name.
+ * @param value - variable value.
+ */
+export declare function setCssVar(name: string, value: string | null): void;
+/**
+ * Deletes specified CSS variable.
+ * @param name - variable name.
+ */
+export declare function deleteCssVar(name: string): void;

package/dist/dts/helpers/isColorDark.d.ts

@@ -0,0 +1,11 @@
+import { either as E } from 'fp-ts';
+/**
+ * @param color - color in any format acceptable by the `toRGB` function.
+ * @returns True if the color is recognized as dark.
+ * @see toRGB
+ */
+export declare function isColorDarkFp(color: string): E.Either<Error, boolean>;
+/**
+ * @see isColorDarkFp
+ */
+export declare const isColorDark: ((color: string) => boolean) & {};

package/dist/dts/helpers/navigation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @returns True, if the current page was reloaded.
+ * @see https://stackoverflow.com/a/36444134/11894710
+ */
+export declare function isPageReload(): boolean;

package/dist/dts/helpers/removeUndefined.d.ts

@@ -0,0 +1,10 @@
+import { UnionRequiredKeys } from '@vbotma/toolkit';
+type RemoveUndefined<T> = {
+    [K in UnionRequiredKeys<T>]-?: T[K];
+};
+/**
+ * @returns Object with keys having undefined values.
+ * @param value - an object to remove undefined values from.
+ */
+export declare function removeUndefined<T extends {}>(value: T): RemoveUndefined<T>;
+export {};

package/dist/dts/helpers/shallowEqual.d.ts

@@ -0,0 +1 @@
+export declare function shallowEqual<T extends object>(a: T, b: T): boolean;