@vbotma/sdk 3.1.8

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

@@ -0,0 +1,131 @@
+import { PostEventError } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { BetterTaskEitherError } from '@vbotma/toolkit';
+import { BetterPromise } from 'better-promises';
+import { either as E, taskEither as TE } from 'fp-ts';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithPostEvent } from '../../fn-options/withPostEvent.js';
+import { WithVersion } from '../../fn-options/withVersion.js';
+import { AsyncOptions } from '../../types.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+export interface QrScannerOptions extends WithVersion, WithPostEvent, SharedFeatureOptions {
+    /**
+     * A function to add a listener to the event determining if the QR scanner
+     * was closed.
+     * @param listener - a listener to add.
+     * @returns A function to remove the listener.
+     */
+    onClosed: (listener: VoidFunction) => VoidFunction;
+    /**
+     * A function to add a listener to the event containing a scanned QR content.
+     * @param listener - a listener to add.
+     * @returns A function to remove the listener.
+     */
+    onTextReceived: (listener: (data: string) => void) => VoidFunction;
+}
+interface SharedOptions extends AsyncOptions {
+    /**
+     * Title to be displayed in the scanner.
+     */
+    text?: string;
+}
+interface CaptureOptions extends SharedOptions {
+    /**
+     * @returns True if the passed QR code should be captured.
+     * @param qr - scanned QR content.
+     */
+    capture: (qr: string) => boolean;
+}
+interface OpenOptions extends SharedOptions {
+    /**
+     * Function which will be called if a QR code was scanned.
+     * @param qr - scanned QR content.
+     */
+    onCaptured: (qr: string) => void;
+}
+/**
+ * @since Mini Apps v6.4
+ */
+export declare class QrScanner {
+    constructor({ version, onClosed, onTextReceived, isTma, postEvent, }: QrScannerOptions);
+    /**
+     * Signal indicating if the scanner is currently opened.
+     */
+    readonly isOpened: Computed<boolean>;
+    /**
+     * Signal indicating if the component is supported.
+     */
+    readonly isSupported: Computed<boolean>;
+    /**
+     * Opens the scanner and returns a task which will be completed with the QR content if the
+     * passed `capture` function returned true.
+     *
+     * Task may also be completed with undefined if the scanner was closed.
+     * @param options - method options.
+     * @returns A promise with QR content presented as string or undefined if the scanner was closed.
+     * @since Mini Apps v6.4
+     * @example
+     * fn.pipe(
+     *   qrScanner.captureFp({
+     *     capture(scannedQr) {
+     *       return scannedQr === 'any expected by me qr';
+     *     }
+     *   }),
+     *   TE.match(
+     *     error => {
+     *       console.error(error);
+     *     },
+     *     qr => {
+     *       console.log('My QR:'), qr;
+     *     }
+     *   ),
+     * );
+     */
+    readonly captureFp: WithChecksFp<(options: CaptureOptions) => (TE.TaskEither<PostEventError | BetterTaskEitherError, string | undefined>), true>;
+    /**
+     * @see captureFp
+     */
+    readonly capture: WithChecks<(options: CaptureOptions) => BetterPromise<string | undefined>, true>;
+    /**
+     * Closes the scanner.
+     * @since Mini Apps v6.4
+     */
+    readonly closeFp: WithChecksFp<() => E.Either<PostEventError, void>, true>;
+    /**
+     * @see close
+     */
+    readonly close: WithChecks<() => void, true>;
+    /**
+     * Opens the scanner and returns a task which will be completed when the scanner was closed.
+     * @param options - method options.
+     * @since Mini Apps v6.4
+     * @example Without `capture` option
+     * if (qrScanner.open.isAvailable()) {
+     *   const qr = await qrScanner.open({ text: 'Scan any QR' });
+     * }
+     * @example
+     * fn.pipe(
+     *   qrScanner.openFp({
+     *     onCaptured(scannedQr) {
+     *       if (scannedQr === 'any expected by me qr') {
+     *         qrScanner.close();
+     *       }
+     *     }
+     *   }),
+     *   TE.match(
+     *     error => {
+     *       console.error(error);
+     *     },
+     *     () => {
+     *       console.log('The scanner was closed');
+     *     }
+     *   ),
+     * );
+     */
+    readonly openFp: WithChecksFp<(options: OpenOptions) => TE.TaskEither<PostEventError, void>, true>;
+    /**
+     * @see openFp
+     */
+    readonly open: WithChecks<(options: OpenOptions) => BetterPromise<void>, true>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { QrScanner, type QrScannerOptions } from './QrScanner.js';
+export { qrScanner } from './instance.js';

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

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

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

@@ -0,0 +1,39 @@
+import { UnknownEnvError } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { BetterPromise } from 'better-promises';
+import { taskEither as TE } from 'fp-ts';
+import { RefreshOptions, RefreshRequestListener } from './types.js';
+/**
+ * Refresh feature class.
+ * @since v9.2
+ */
+export declare class Refresh {
+    constructor({}: RefreshOptions);
+    /**
+     * Signal indicating if refresh is currently in progress.
+     */
+    readonly isRefreshing: Computed<boolean>;
+    /**
+     * Notifies native app that refresh has completed.
+     * @since v9.2
+     */
+    readonly finishRefreshFp: () => TE.TaskEither<UnknownEnvError, void>;
+    /**
+     * @see finishRefreshFp
+     */
+    readonly finishRefresh: () => BetterPromise<void>;
+    /**
+     * Subscribes to refresh request events from native app.
+     * @param listener - callback function to execute when refresh is requested
+     * @returns unsubscribe function
+     * @since v9.2
+     * @example
+     * const unsubscribe = refresh.onRefreshRequest(() => {
+     *   // Fetch new data
+     *   fetchData().then(() => {
+     *     refresh.finishRefresh();
+     *   });
+     * });
+     */
+    readonly onRefreshRequest: (listener: RefreshRequestListener) => VoidFunction;
+}

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

@@ -0,0 +1,3 @@
+export type { RefreshOptions, RefreshRequestListener, } from './types.js';
+export { Refresh } from './Refresh.js';
+export { refresh } from './instance.js';

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

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

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

@@ -0,0 +1,7 @@
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+export interface RefreshOptions extends SharedFeatureOptions {
+}
+/**
+ * Callback function called when refresh is requested by native app.
+ */
+export type RefreshRequestListener = () => void;

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

@@ -0,0 +1,253 @@
+import { PostEventError, SecondaryButtonPosition } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { RGB } from '@vbotma/types';
+import { either as E } from 'fp-ts';
+import { ButtonOptions } from '../../composables/Button.js';
+import { MaybeAccessor } from '../../types.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+type SecondaryButtonEither = E.Either<PostEventError, void>;
+export interface SecondaryButtonState {
+    isVisible: boolean;
+    bgColor?: RGB;
+    hasShineEffect: boolean;
+    isEnabled: boolean;
+    isLoaderVisible: boolean;
+    text: string;
+    textColor?: RGB;
+    position: SecondaryButtonPosition;
+}
+export interface SecondaryButtonOptions extends Omit<ButtonOptions<SecondaryButtonState, 'web_app_setup_secondary_button'>, 'initialState' | 'method' | 'payload'> {
+    /**
+     * Default values for different kinds of the button properties.
+     */
+    defaults: {
+        bgColor: MaybeAccessor<RGB>;
+        textColor: MaybeAccessor<RGB>;
+    };
+}
+/**
+ * @since Mini Apps v7.10
+ */
+export declare class SecondaryButton {
+    constructor({ defaults, ...options }: SecondaryButtonOptions);
+    /**
+     * Signal indicating if the component is supported.
+     */
+    readonly isSupported: Computed<boolean>;
+    /**
+     * The button position relative to the main one.
+     */
+    readonly position: Computed<SecondaryButtonPosition>;
+    /**
+     * The button background color.
+     */
+    readonly bgColor: Computed<RGB>;
+    /**
+     * True if the button has a shining effect.
+     */
+    readonly hasShineEffect: Computed<boolean>;
+    /**
+     * True if the button is clickable.
+     */
+    readonly isEnabled: Computed<boolean>;
+    /**
+     * True if the button loader is visible.
+     */
+    readonly isLoaderVisible: Computed<boolean>;
+    /**
+     * True if the button is visible.
+     */
+    readonly isVisible: Computed<boolean>;
+    /**
+     * Signal indicating if the component is currently mounted.
+     */
+    readonly isMounted: Computed<boolean>;
+    /**
+     * The complete button state.
+     */
+    readonly state: Computed<SecondaryButtonState>;
+    /**
+     * The button displayed text.
+     */
+    readonly text: Computed<string>;
+    /**
+     * The button text color.
+     *
+     * Note that this value is computed based on the external defaults. For
+     * example, if not explicitly set, this value may be equal to one of theme
+     * params colors.
+     */
+    readonly textColor: Computed<RGB>;
+    /**
+     * Shows the button.
+     * @since Mini Apps v7.10
+     */
+    readonly showFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see showFp
+     */
+    readonly show: WithChecks<() => void, true>;
+    /**
+     * Hides the button.
+     * @since Mini Apps v7.10
+     */
+    readonly hideFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see hideFp
+     */
+    readonly hide: WithChecks<() => void, true>;
+    /**
+     * Enables the button.
+     * @since Mini Apps v7.10
+     */
+    readonly enableFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see enableFp
+     */
+    readonly enable: WithChecks<() => void, true>;
+    /**
+     * Enables the button.
+     * @since Mini Apps v7.10
+     */
+    readonly enableShineEffectFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see enableShineEffectFp
+     */
+    readonly enableShineEffect: WithChecks<() => void, true>;
+    /**
+     * Disables the button.
+     * @since Mini Apps v7.10
+     */
+    readonly disableFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see disableFp
+     */
+    readonly disable: WithChecks<() => void, true>;
+    /**
+     * Enables the button.
+     * @since Mini Apps v7.10
+     */
+    readonly disableShineEffectFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see disableShineEffectFp
+     */
+    readonly disableShineEffect: WithChecks<() => void, true>;
+    /**
+     * Updates the button background color.
+     * @since Mini Apps v7.10
+     */
+    readonly setBgColorFp: WithChecksFp<(value: RGB) => SecondaryButtonEither, true>;
+    /**
+     * @see setBgColorFp
+     */
+    readonly setBgColor: WithChecks<(value: RGB) => void, true>;
+    /**
+     * Updates the button text color.
+     * @since Mini Apps v7.10
+     */
+    readonly setTextColorFp: WithChecksFp<(value: RGB) => SecondaryButtonEither, true>;
+    /**
+     * @see setTextColorFp
+     */
+    readonly setTextColor: WithChecks<(value: RGB) => void, true>;
+    /**
+     * Updates the button text.
+     * @since Mini Apps v7.10
+     */
+    readonly setTextFp: WithChecksFp<(value: string) => SecondaryButtonEither, true>;
+    /**
+     * @see setTextFp
+     */
+    readonly setText: WithChecks<(value: string) => void, true>;
+    /**
+     * Updates the button position.
+     * @since Mini Apps v7.10
+     */
+    readonly setPositionFp: WithChecksFp<(position: SecondaryButtonPosition) => SecondaryButtonEither, true>;
+    /**
+     * @see setPositionFp
+     */
+    readonly setPosition: WithChecks<(position: SecondaryButtonPosition) => void, true>;
+    /**
+     * Shows the button loader.
+     * @since Mini Apps v7.10
+     */
+    readonly showLoaderFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see showLoaderFp
+     */
+    readonly showLoader: WithChecks<() => void, true>;
+    /**
+     * Hides the button loader.
+     * @since Mini Apps v7.10
+     */
+    readonly hideLoaderFp: WithChecksFp<() => SecondaryButtonEither, true>;
+    /**
+     * @see hideLoaderFp
+     */
+    readonly hideLoader: WithChecks<() => void, true>;
+    /**
+     * Updates the button state.
+     * @param state - updates to apply.
+     * @since Mini Apps v7.10
+     * @example
+     * button.setParams({
+     *   text: 'Submit',
+     *   isEnabled: true,
+     *   hasShineEffect: true,
+     * });
+     */
+    readonly setParamsFp: WithChecksFp<(state: Partial<SecondaryButtonState>) => SecondaryButtonEither, true>;
+    /**
+     * @see setParamsFp
+     */
+    readonly setParams: WithChecks<(state: Partial<SecondaryButtonState>) => void, true>;
+    /**
+     * Mounts the component restoring its state.
+     * @since Mini Apps v7.10
+     */
+    readonly mountFp: WithChecksFp<() => void, true>;
+    /**
+     * @see mountFp
+     */
+    readonly mount: WithChecks<() => void, true>;
+    /**
+     * Unmounts the component.
+     */
+    readonly unmount: () => void;
+    /**
+     * Adds a new button listener.
+     * @param listener - event listener.
+     * @param once - should the listener be called only once.
+     * @returns A function to remove bound listener.
+     * @since Mini Apps v7.10
+     * @example
+     * const off = button.onClick(() => {
+     *   console.log('User clicked the button');
+     *   off();
+     * });
+     */
+    readonly onClickFp: WithChecksFp<(listener: VoidFunction, once?: boolean) => VoidFunction, true>;
+    /**
+     * @see onClick
+     */
+    readonly onClick: WithChecks<(listener: VoidFunction, once?: boolean) => VoidFunction, true>;
+    /**
+     * Removes the button click listener.
+     * @param listener - event listener.
+     * @param once - should the listener be called only once.
+     * @since Mini Apps v7.10
+     * @example
+     * function listener() {
+     *   console.log('User clicked the button');
+     *   button.offClick(listener);
+     * }
+     * button.onClick(listener);
+     */
+    readonly offClickFp: WithChecksFp<(listener: VoidFunction, once?: boolean) => void, true>;
+    /**
+     * @see offClick
+     */
+    readonly offClick: WithChecks<(listener: VoidFunction, once?: boolean) => void, true>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { secondaryButton } from './instance.js';
+export { type SecondaryButtonOptions, SecondaryButton, type SecondaryButtonState, } from './SecondaryButton.js';

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

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

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

@@ -0,0 +1,68 @@
+import { RequestError } from '@vbotma/bridge';
+import { taskEither as TE } from 'fp-ts';
+import { SecureStorageMethodError } from '../../errors.js';
+import { SharedFeatureOptions } from '../../fn-options/sharedFeatureOptions.js';
+import { WithCreateRequestId } from '../../fn-options/withCreateRequestId.js';
+import { WithRequest } from '../../fn-options/withRequest.js';
+import { WithVersion } from '../../fn-options/withVersion.js';
+import { WithChecks, WithChecksFp } from '../../with-checks/withChecksFp.js';
+export type SecureStorageError = RequestError | SecureStorageMethodError;
+export interface SecureStorageOptions extends SharedFeatureOptions, WithVersion, WithRequest, WithCreateRequestId {
+}
+/**
+ * @since Mini Apps v9.0
+ */
+export declare class SecureStorage {
+    constructor({ isTma, request, version, createRequestId }: SecureStorageOptions);
+    /**
+      * Retrieves an item using its key.
+      * @since Mini Apps v9.0
+      */
+    readonly getItemFp: WithChecksFp<(key: string) => TE.TaskEither<SecureStorageError, {
+        value: string | null;
+        canRestore: boolean;
+    }>, true>;
+    /**
+     * @see getItemFp
+     */
+    readonly getItem: WithChecks<(key: string) => Promise<{
+        value: string | null;
+        canRestore: boolean;
+    }>, true>;
+    /**
+     * Restores an item from the storage.
+     * @since Mini Apps v9.0
+     */
+    readonly restoreItemFp: WithChecksFp<(key: string) => TE.TaskEither<SecureStorageError, string | null>, true>;
+    /**
+     * @see restoreItemFp
+     */
+    readonly restoreItem: WithChecks<(key: string) => Promise<string | null>, true>;
+    /**
+      * Sets a new item in the storage.
+      * @since Mini Apps v9.0
+      */
+    readonly setItemFp: WithChecksFp<(key: string, value: string | null) => TE.TaskEither<SecureStorageError, void>, true>;
+    /**
+     * @see setItemFp
+     */
+    readonly setItem: WithChecks<(key: string, value: string | null) => Promise<void>, true>;
+    /**
+      * Removes a key from the storage.
+      * @since Mini Apps v9.0
+      */
+    readonly deleteItemFp: WithChecksFp<(key: string) => TE.TaskEither<SecureStorageError, void>, true>;
+    /**
+     * @see deleteItemFp
+     */
+    readonly deleteItem: WithChecks<(key: string) => Promise<void>, true>;
+    /**
+      * Removes all keys from the storage.
+      * @since Mini Apps v9.0
+      */
+    readonly clearFp: WithChecksFp<() => TE.TaskEither<SecureStorageError, void>, true>;
+    /**
+     * @see clearFp
+     */
+    readonly clear: WithChecks<() => Promise<void>, true>;
+}

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

@@ -0,0 +1,2 @@
+export { SecureStorage, type SecureStorageOptions, type SecureStorageError } from './SecureStorage.js';
+export { secureStorage } from './instance.js';

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

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

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

@@ -0,0 +1,96 @@
+import { PostEventError } from '@vbotma/bridge';
+import { Computed } from '@vbotma/signals';
+import { either as E } from 'fp-ts';
+import { ButtonOptions } from '../../composables/Button.js';
+import { WithChecksFp, WithChecks } from '../../with-checks/withChecksFp.js';
+export interface SettingsButtonState {
+    isVisible: boolean;
+}
+export type SettingsButtonOptions = Omit<ButtonOptions<SettingsButtonState, 'web_app_setup_settings_button'>, 'method' | 'payload' | 'initialState'>;
+/**
+ * @since Mini Apps v6.10
+ */
+export declare class SettingsButton {
+    constructor(options: SettingsButtonOptions);
+    /**
+     * Signal indicating if the component is currently visible.
+     */
+    readonly isVisible: Computed<boolean>;
+    /**
+     * Signal indicating if the component is currently mounted.
+     */
+    readonly isMounted: Computed<boolean>;
+    /**
+     * Signal indicating if the component is supported.
+     */
+    readonly isSupported: Computed<boolean>;
+    /**
+     * Hides the button.
+     * @since Mini Apps v6.10
+     */
+    readonly hideFp: WithChecksFp<() => E.Either<PostEventError, void>, true>;
+    /**
+     * @see hideFp
+     */
+    readonly hide: WithChecks<() => void, true>;
+    /**
+     * Shows the button.
+     * @since Mini Apps v6.10
+     */
+    readonly showFp: WithChecksFp<() => E.Either<PostEventError, void>, true>;
+    /**
+     * @see showFp
+     */
+    readonly show: WithChecks<() => void, true>;
+    /**
+     * Adds a new button listener.
+     * @param listener - event listener.
+     * @param once - should the listener be called only once.
+     * @returns A function to remove bound listener.
+     * @since Mini Apps v6.10
+     * @example
+     * const off = button.onClick(() => {
+     *   console.log('User clicked the button');
+     *   off();
+     * });
+     */
+    readonly onClickFp: WithChecksFp<(listener: VoidFunction, once?: boolean) => VoidFunction, true>;
+    /**
+     * @see onClickFp
+     */
+    readonly onClick: WithChecks<(listener: VoidFunction, once?: boolean) => VoidFunction, true>;
+    /**
+     * Removes the button click listener.
+     * @param listener - event listener.
+     * @param once - should the listener be called only once.
+     * @since Mini Apps v6.10
+     * @example
+     * function listener() {
+     *   console.log('User clicked the button');
+     *   button.offClick(listener);
+     * }
+     * button.onClick(listener);
+     */
+    readonly offClickFp: WithChecksFp<(listener: VoidFunction, once?: boolean) => void, true>;
+    /**
+     * @see offClickFp
+     */
+    readonly offClick: WithChecks<(listener: VoidFunction, once?: boolean) => void, true>;
+    /**
+     * Mounts the component restoring its state.
+     * @since Mini Apps v6.10
+     */
+    readonly mountFp: WithChecksFp<() => void, true>;
+    /**
+     * @see mountFp
+     */
+    readonly mount: WithChecks<() => void, true>;
+    /**
+     * Unmounts the component.
+     *
+     * Note that this function does not remove listeners added via the `onClick`
+     * function, so you have to remove them on your own.
+     * @see onClick
+     */
+    readonly unmount: () => void;
+}

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

@@ -0,0 +1,2 @@
+export { settingsButton } from './instance.js';
+export { type SettingsButtonOptions, SettingsButton, type SettingsButtonState, } from './SettingsButton.js';

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

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

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

@@ -0,0 +1,45 @@
+import { RequestError } from '@vbotma/bridge';
+import { BetterPromise } from 'better-promises';
+import { taskEither as TE } from 'fp-ts';
+import { StoragePermissionOptions, RequestStorageAccessOptions, StorageAccessResult } from './types.js';
+/**
+ * Storage Permission feature class.
+ * Allows requesting access to device storage to select files or folders.
+ * @since v9.3
+ */
+export declare class StoragePermission {
+    constructor({ request }: StoragePermissionOptions);
+    /**
+     * Requests storage access with specified options.
+     * Returns a promise that resolves with selected files/folders.
+     * @param options - Storage access options
+     * @since v9.3
+     */
+    readonly requestAccessFp: (options: RequestStorageAccessOptions) => TE.TaskEither<RequestError, StorageAccessResult>;
+    /**
+     * @see requestAccessFp
+     */
+    readonly requestAccess: (options: RequestStorageAccessOptions) => BetterPromise<StorageAccessResult>;
+    /**
+     * Convenience method to select a single file.
+     * @param options - Optional file selection options
+     */
+    readonly selectFile: (options?: {
+        accept?: string[];
+        maxFileSize?: number;
+        readContent?: boolean;
+    }) => BetterPromise<StorageAccessResult>;
+    /**
+     * Convenience method to select multiple files.
+     * @param options - Optional file selection options
+     */
+    readonly selectFiles: (options?: {
+        accept?: string[];
+        maxFileSize?: number;
+        readContent?: boolean;
+    }) => BetterPromise<StorageAccessResult>;
+    /**
+     * Convenience method to select a folder.
+     */
+    readonly selectFolder: () => BetterPromise<StorageAccessResult>;
+}