@tma.js/sdk 1.5.2 → 2.0.0

package/dist/dts/bridge/utils/request.d.ts

@@ -0,0 +1,35 @@
+import { ExecuteWithOptions, If, IsNever } from '../../types/index.js';
+import { MiniAppsEventListener, MiniAppsEventName, MiniAppsEventPayload } from '../events/types.js';
+import { MiniAppsMethodName, MiniAppsMethodParams } from '../methods/types/index.js';
+
+interface BasicOptions<Method extends MiniAppsMethodName, Event extends MiniAppsEventName> extends ExecuteWithOptions {
+    /**
+     * Mini Apps method name.
+     */
+    method: Method;
+    /**
+     * One or many tracked Mini Apps events.
+     */
+    event: Event | Event[];
+    /**
+     * Should return true in case, this event should be captured. If not specified,
+     * request will be captured automatically.
+     */
+    capture?: If<IsNever<MiniAppsEventListener<Event>>, () => boolean, (payload: MiniAppsEventPayload<Event>) => boolean>;
+}
+/**
+ * `request` method options.
+ */
+export type RequestOptions<Method extends MiniAppsMethodName, Event extends MiniAppsEventName> = BasicOptions<Method, Event> & If<IsNever<MiniAppsMethodParams<Method>>, {}, {
+    /**
+     * List of method parameters.
+     */
+    params: MiniAppsMethodParams<Method>;
+}>;
+/**
+ * Calls specified Mini Apps method and captures one of the specified events. Returns promise
+ * which will be resolved in case, specified event was captured.
+ * @param options - method options.
+ */
+export declare function request<Method extends MiniAppsMethodName, Event extends MiniAppsEventName>(options: RequestOptions<Method, Event>): Promise<MiniAppsEventPayload<Event>>;
+export {};

package/dist/dts/classes/State/State.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from '../../events/event-emitter/EventEmitter.js';
+import { StateEvents } from './types.js';
+import { StringKeys } from '../../types/utils.js';
+
+type Emitter<State extends object> = EventEmitter<StateEvents<State>>;
+export declare class State<State extends object> {
+    /**
+     * Initial state.
+     */
+    private readonly state;
+    private readonly ee;
+    constructor(
+    /**
+     * Initial state.
+     */
+    state: State);
+    /**
+     * Clones current state and returns its copy.
+     */
+    clone(): State;
+    /**
+     * Sets value by key.
+     * @param key - state key.
+     * @param value - value to set.
+     */
+    set<K extends StringKeys<State>>(key: K, value: State[K]): void;
+    /**
+     * Sets several values simultaneously.
+     * @param state - partial state.
+     */
+    set(state: Partial<State>): void;
+    /**
+     * Returns value by specified key.
+     * @param key - state key.
+     */
+    get<K extends StringKeys<State>>(key: K): State[K];
+    /**
+     * Adds new event listener.
+     */
+    on: Emitter<State>['on'];
+    /**
+     * Removes event listener.
+     */
+    off: Emitter<State>['off'];
+}
+export {};

package/dist/dts/classes/State/types.d.ts

@@ -0,0 +1,29 @@
+import { StringKeys } from '../../types/utils.js';
+
+/**
+ * Creates a map with all events emitted by BaseComponent.
+ * @example
+ * ```ts
+ * type A = StateEvents<{
+ *   name: string;
+ *   age: number;
+ *   isRegistered: boolean;
+ * }>;
+ *
+ * // Will be:
+ * {
+ *   "change:name": (currentValue: string) => void;
+ *   "change:age": (currentValue: number) => void;
+ *   "change:isRegistered": (currentValue: boolean) => void;
+ *   "change": () => void;
+ * }
+ * ```
+ */
+export type StateEvents<State extends object> = {
+    [Event in `change:${StringKeys<State>}`]: (currentValue: Event extends `change:${infer T extends StringKeys<State>}` ? State[T] : never) => void;
+} & {
+    /**
+     * Something has changed in the state.
+     */
+    change: (currentState: State) => void;
+};

package/dist/dts/classes/WithStateUtils.d.ts

@@ -0,0 +1,18 @@
+import { State } from './State/State.js';
+
+export declare class WithStateUtils<Shape extends object> {
+    protected state: State<Shape>;
+    constructor(shape: Shape);
+    /**
+     * Gets the state value.
+     */
+    protected get: State<Shape>['get'];
+    /**
+     * Sets the state value.
+     */
+    protected set: State<Shape>['set'];
+    /**
+     * Clones the current state.
+     */
+    protected clone: State<Shape>['clone'];
+}

package/dist/dts/classes/WithSupports.d.ts

@@ -0,0 +1,19 @@
+import { MiniAppsMethodName } from '../bridge/methods/types/methods.js';
+import { SupportsFn } from '../supports/types.js';
+import { Version } from '../version/types.js';
+
+export declare class WithSupports<SupportsMethod extends string> {
+    constructor(
+    /**
+     * Mini Apps version.
+     */
+    version: Version, 
+    /**
+     * Supports method schema.
+     */
+    supportsSchema: Record<SupportsMethod, MiniAppsMethodName>);
+    /**
+     * @returns True, if specified method is supported by the current component.
+     */
+    supports: SupportsFn<SupportsMethod>;
+}

package/dist/dts/classes/WithSupportsAndStateUtils.d.ts

@@ -0,0 +1,24 @@
+import { WithStateUtils } from './WithStateUtils.js';
+import { MiniAppsMethodName } from '../bridge/methods/types/methods.js';
+import { SupportsFn } from '../supports/types.js';
+import { Version } from '../version/types.js';
+
+export declare class WithSupportsAndStateUtils<StateShape extends object, SupportsMethod extends string> extends WithStateUtils<StateShape> {
+    constructor(
+    /**
+     * Initial state.
+     */
+    stateShape: StateShape, 
+    /**
+     * Mini Apps version.
+     */
+    version: Version, 
+    /**
+     * Supports method schema.
+     */
+    supportsSchema: Record<SupportsMethod, MiniAppsMethodName>);
+    /**
+     * @returns True, if specified method is supported by the current component.
+     */
+    supports: SupportsFn<SupportsMethod>;
+}

package/dist/dts/classes/WithSupportsAndTrackableState.d.ts

@@ -0,0 +1,16 @@
+import { WithSupportsAndStateUtils } from './WithSupportsAndStateUtils.js';
+import { StateEvents } from './State/types.js';
+import { EventEmitter } from '../events/event-emitter/EventEmitter.js';
+
+type Emitter<StateShape extends object> = EventEmitter<StateEvents<StateShape>>;
+export declare class WithSupportsAndTrackableState<StateShape extends object, SupportsMethod extends string> extends WithSupportsAndStateUtils<StateShape, SupportsMethod> {
+    /**
+     * Adds a new event listener.
+     */
+    on: Emitter<StateShape>['on'];
+    /**
+     * Removes the event listener.
+     */
+    off: Emitter<StateShape>['off'];
+}
+export {};

package/dist/dts/classes/WithTrackableState.d.ts

@@ -0,0 +1,16 @@
+import { WithStateUtils } from './WithStateUtils.js';
+import { StateEvents } from './State/types.js';
+import { EventEmitter } from '../events/event-emitter/EventEmitter.js';
+
+type Emitter<StateShape extends object> = EventEmitter<StateEvents<StateShape>>;
+export declare class WithTrackableState<StateShape extends object> extends WithStateUtils<StateShape> {
+    /**
+     * Adds a new event listener.
+     */
+    on: Emitter<StateShape>['on'];
+    /**
+     * Removes the event listener.
+     */
+    off: Emitter<StateShape>['off'];
+}
+export {};

package/dist/dts/classnames/mergeClassNames.d.ts

@@ -1,4 +1,5 @@
-import type { UnionOptionalKeys, UnionRequiredKeys } from '../types/unions.js';
+import { UnionOptionalKeys, UnionRequiredKeys } from '../types/unions.js';
+
 export type MergeClassNames<Tuple extends any[]> = Exclude<Tuple[number], number | string | null | undefined | any[] | boolean> extends infer Union ? {
     [K in UnionRequiredKeys<Union>]: string;
 } & {

package/dist/dts/colors/isRGB.d.ts

@@ -1,4 +1,5 @@
-import type { RGB } from './types.js';
+import { RGB } from './types.js';
+
 /**
  * Returns true in case, passed value has #RRGGBB format.
  * @param value - value to check.

package/dist/dts/colors/isRGBShort.d.ts

@@ -1,4 +1,5 @@
-import type { RGBShort } from './types.js';
+import { RGBShort } from './types.js';
+
 /**
  * Returns true in case, passed value has #RGB format.
  * @param value - value to check.

package/dist/dts/colors/toRGB.d.ts

@@ -1,4 +1,5 @@
-import type { RGB } from './types.js';
+import { RGB } from './types.js';
+
 /**
  * Converts passed value to #RRGGBB format. Accepts following color formats:
  * - `#RGB`

package/dist/dts/components/BackButton/BackButton.d.ts

@@ -0,0 +1,41 @@
+import { WithSupportsAndStateUtils } from '../../classes/WithSupportsAndStateUtils.js';
+import { PostEvent } from '../../bridge/methods/postEvent.js';
+import { BackButtonEvents, BackButtonState } from './types.js';
+import { EventEmitter } from '../../events/event-emitter/EventEmitter.js';
+import { Version } from '../../version/types.js';
+
+type Emitter = EventEmitter<BackButtonEvents>;
+/**
+ * @see Usage: https://docs.telegram-mini-apps.com/platform/back-button
+ * @see API: https://docs.telegram-mini-apps.com/packages/tma-js-sdk/components/back-button
+ */
+export declare class BackButton extends WithSupportsAndStateUtils<BackButtonState, 'show' | 'hide'> {
+    private readonly postEvent;
+    constructor(isVisible: boolean, version: Version, postEvent: PostEvent);
+    private set isVisible(value);
+    /**
+     * True if BackButton is currently visible.
+     */
+    get isVisible(): boolean;
+    /**
+     * Hides the BackButton.
+     */
+    hide(): void;
+    /**
+     * Adds a new event listener.
+     * @param event - event to listen.
+     * @param listener - listener to add.
+     */
+    on: Emitter['on'];
+    /**
+     * Removes the event listener.
+     * @param event - event to listen.
+     * @param listener - listener to remove.
+     */
+    off: Emitter['off'];
+    /**
+     * Shows the BackButton.
+     */
+    show(): void;
+}
+export {};

package/dist/dts/components/BackButton/initBackButton.d.ts

@@ -0,0 +1,7 @@
+import { BackButton } from './BackButton.js';
+
+/**
+ * @returns A new initialized instance of the `BackButton` class.
+ * @see BackButton
+ */
+export declare const initBackButton: import('../../index.js').InitComponentFn<"version", BackButton, import('./types.js').BackButtonState>;

package/dist/dts/components/BackButton/types.d.ts

@@ -0,0 +1,25 @@
+import { StateEvents } from '../../classes/State/types.js';
+
+/**
+ * BackButton internal state.
+ */
+export interface BackButtonState {
+    isVisible: boolean;
+}
+/**
+ * BackButton trackable events.
+ */
+export interface BackButtonEvents extends StateEvents<BackButtonState> {
+    /**
+     * The BackButton was clicked.
+     */
+    click: () => void;
+}
+/**
+ * BackButton event name.
+ */
+export type BackButtonEventName = keyof BackButtonEvents;
+/**
+ * BackButton event listener.
+ */
+export type BackButtonEventListener<E extends BackButtonEventName> = BackButtonEvents[E];

package/dist/dts/components/BiometryManager/BiometryManager.d.ts

@@ -0,0 +1,61 @@
+import { WithSupportsAndTrackableState } from '../../classes/WithSupportsAndTrackableState.js';
+import { BiometryType } from '../../bridge/events/types.js';
+import { BiometryManagerAuthenticateOptions, BiometryManagerProps, BiometryManagerRequestAccessOptions, BiometryManagerState, BiometryManagerUpdateTokenOptions } from './types.js';
+
+export declare class BiometryManager extends WithSupportsAndTrackableState<BiometryManagerState, 'auth' | 'openSettings' | 'requestAccess' | 'updateToken'> {
+    private readonly postEvent;
+    private authPromise?;
+    private accessPromise?;
+    constructor({ postEvent, version, ...rest }: BiometryManagerProps);
+    /**
+     * Shows whether biometry is available.
+     */
+    get available(): boolean;
+    /**
+     * Shows whether permission to use biometrics has been granted.
+     */
+    get accessGranted(): boolean;
+    /**
+     * Shows whether if permission to use biometrics has been requested.
+     */
+    get accessRequested(): boolean;
+    /**
+     * Authenticates the user using biometrics.
+     * @param options - method options.
+     * @since 7.2
+     * @returns Token from the local secure storage, if authentication was successful.
+     */
+    authenticate({ reason, ...rest }: BiometryManagerAuthenticateOptions): Promise<string | undefined>;
+    /**
+     * A unique device identifier that can be used to match the token to the device.
+     */
+    get deviceId(): string;
+    /**
+     * Opens the biometric access settings for bots. Useful when you need to request biometrics
+     * access to users who haven't granted it yet.
+     *
+     * _Note that this method can be called only in response to user interaction with the Mini App
+     * interface (e.g. a click inside the Mini App or on the main button)_.
+     * @since 7.2
+     */
+    openSettings(): void;
+    /**
+     * Requests permission to use biometrics.
+     * @since 7.2
+     * @returns Promise with true, if access was granted.
+     */
+    requestAccess({ reason, ...rest }?: BiometryManagerRequestAccessOptions): Promise<boolean>;
+    /**
+     * The type of biometrics currently available on the device.
+     */
+    get biometryType(): BiometryType | undefined;
+    /**
+     * Shows whether token was saved previously in the local secure storage.
+     */
+    get tokenSaved(): boolean;
+    /**
+     * Updates the biometric token in a secure storage on the device.
+     * @returns Promise with `true`, if token was updated.
+     */
+    updateToken({ token, ...rest }?: BiometryManagerUpdateTokenOptions): Promise<boolean>;
+}

package/dist/dts/components/BiometryManager/formatEvent.d.ts

@@ -0,0 +1,34 @@
+import { BiometryType, MiniAppsEventPayload } from '../../bridge/events/types.js';
+
+export interface FormatBiometryInfoResult {
+    /**
+     * Shows whether biometry is available.
+     */
+    available: boolean;
+    /**
+     * Shows whether permission to use biometrics has been requested.
+     */
+    accessRequested: boolean;
+    /**
+     * Shows whether permission to use biometrics has been granted.
+     */
+    accessGranted: boolean;
+    /**
+     * A unique device identifier that can be used to match the token to the device.
+     */
+    deviceId: string;
+    /**
+     * Show whether local storage contains previously saved token.
+     */
+    tokenSaved: boolean;
+    /**
+     * The type of biometrics currently available on the device.
+     */
+    type: BiometryType;
+}
+/**
+ * Converts `biometry_info_received` to some common shape.
+ * @param event - event payload.
+ * @see biometry_info_received
+ */
+export declare function formatEvent(event: MiniAppsEventPayload<'biometry_info_received'>): FormatBiometryInfoResult;

package/dist/dts/components/BiometryManager/initBiometryManager.d.ts

@@ -0,0 +1,7 @@
+import { BiometryManager } from './BiometryManager.js';
+
+/**
+ * @returns A promise with a new initialized instance of the `BiometryManager` class.
+ * @see BiometryManager
+ */
+export declare const initBiometryManager: import('../../index.js').InitComponentFn<"version", Promise<BiometryManager>, import('./types.js').BiometryManagerState>;

package/dist/dts/components/BiometryManager/requestBiometryInfo.d.ts

@@ -0,0 +1,8 @@
+import { ExecuteWithOptions } from '../../types/index.js';
+import { FormatBiometryInfoResult } from './formatEvent.js';
+
+/**
+ * Requests biometry information.
+ * @param options - additional execution options.
+ */
+export declare function requestBiometryInfo(options?: ExecuteWithOptions): Promise<FormatBiometryInfoResult>;

package/dist/dts/components/BiometryManager/types.d.ts

@@ -0,0 +1,40 @@
+import { BiometryType } from '../../bridge/events/types.js';
+import { PostEvent } from '../../bridge/methods/postEvent.js';
+import { ExecuteWithTimeout, Maybe } from '../../types/index.js';
+import { Version } from '../../version/types.js';
+
+export interface BiometryManagerState {
+    accessGranted: boolean;
+    accessRequested: boolean;
+    available: boolean;
+    deviceId: string;
+    tokenSaved: boolean;
+    token?: string;
+    biometryType?: BiometryType;
+}
+export interface BiometryManagerProps extends BiometryManagerState {
+    postEvent: PostEvent;
+    version: Version;
+}
+export interface BiometryManagerAuthenticateOptions extends ExecuteWithTimeout {
+    /**
+     * The text to be displayed to a user in the popup describing why you are
+     * asking them to authenticate and what action you will be taking based on that
+     * authentication, 0-128 characters.
+     */
+    reason?: Maybe<string>;
+}
+export interface BiometryManagerUpdateTokenOptions extends ExecuteWithTimeout {
+    /**
+     * Token to save in the local device secure storage. Passing `null`, `undefined` or empty string
+     * removes it from the storage.
+     */
+    token?: Maybe<string>;
+}
+export interface BiometryManagerRequestAccessOptions extends ExecuteWithTimeout {
+    /**
+     * The text to be displayed to a user in the popup describing why the bot needs access to
+     * biometrics, 0-128 characters.
+     */
+    reason?: Maybe<string>;
+}

package/dist/dts/components/ClosingBehavior/ClosingBehavior.d.ts

@@ -0,0 +1,26 @@
+import { WithTrackableState } from '../../classes/WithTrackableState.js';
+import { PostEvent } from '../../bridge/methods/postEvent.js';
+import { ClosingBehaviorState } from './types.js';
+
+/**
+ * @see Usage: https://docs.telegram-mini-apps.com/platform/closing-behavior
+ * @see API: https://docs.telegram-mini-apps.com/packages/tma-js-sdk/components/closing-behavior
+ */
+export declare class ClosingBehavior extends WithTrackableState<ClosingBehaviorState> {
+    private readonly postEvent;
+    constructor(isConfirmationNeeded: boolean, postEvent: PostEvent);
+    private set isConfirmationNeeded(value);
+    /**
+     * True, if the confirmation dialog should be shown while the user is trying to close
+     * the Mini App.
+     */
+    get isConfirmationNeeded(): boolean;
+    /**
+     * Disables the confirmation dialog when closing the Mini App.
+     */
+    disableConfirmation(): void;
+    /**
+     * Enables the confirmation dialog when closing the Mini App.
+     */
+    enableConfirmation(): void;
+}

package/dist/dts/components/ClosingBehavior/initClosingBehavior.d.ts

@@ -0,0 +1,7 @@
+import { ClosingBehavior } from './ClosingBehavior.js';
+
+/**
+ * @returns A new initialized instance of the `ClosingBehavior` class.
+ * @see ClosingBehavior
+ */
+export declare const initClosingBehavior: import('../../index.js').InitComponentFn<never, ClosingBehavior, import('./types.js').ClosingBehaviorState>;

package/dist/dts/components/{closing-behavior → ClosingBehavior}/types.d.ts

@@ -1,7 +1,20 @@
-import type { StateEvents } from '../../state/types.js';
+import { StateEvents } from '../../classes/State/types.js';
+
+/**
+ * ClosingBehavior internal state.
+ */
 export interface ClosingBehaviorState {
     isConfirmationNeeded: boolean;
 }
+/**
+ * ClosingBehavior trackable events.
+ */
 export type ClosingBehaviorEvents = StateEvents<ClosingBehaviorState>;
+/**
+ * ClosingBehavior event name.
+ */
 export type ClosingBehaviorEventName = keyof ClosingBehaviorEvents;
+/**
+ * ClosingBehavior event listener.
+ */
 export type ClosingBehaviorEventListener<E extends ClosingBehaviorEventName> = ClosingBehaviorEvents[E];

package/dist/dts/components/{cloud-storage → CloudStorage}/CloudStorage.d.ts

@@ -1,12 +1,16 @@
-import { postEvent as defaultPostEvent } from '../../bridge/methods/postEvent.js';
-import type { SupportsFunc } from '../../supports/types.js';
-import type { ExecuteWithTimeout } from '../../types/methods.js';
-import type { CreateRequestIdFunc } from '../../types/request-id.js';
-import type { Version } from '../../version/types.js';
-export declare class CloudStorage {
+import { WithSupports } from '../../classes/WithSupports.js';
+import { PostEvent } from '../../bridge/methods/postEvent.js';
+import { CreateRequestIdFn } from '../../request-id/types.js';
+import { ExecuteWithTimeout } from '../../types/methods.js';
+import { Version } from '../../version/types.js';
+
+/**
+ * @see API: https://docs.telegram-mini-apps.com/packages/tma-js-sdk/components/cloud-storage
+ */
+export declare class CloudStorage extends WithSupports<'delete' | 'get' | 'getKeys' | 'set'> {
     private readonly createRequestId;
     private readonly postEvent;
-    constructor(version: Version, createRequestId: CreateRequestIdFunc, postEvent?: typeof defaultPostEvent);
+    constructor(version: Version, createRequestId: CreateRequestIdFn, postEvent: PostEvent);
     /**
      * Deletes specified key or keys from the cloud storage.
      * @param keyOrKeys - key or keys to delete.
@@ -40,8 +44,4 @@ export declare class CloudStorage {
      * @param options - request execution options.
      */
     set(key: string, value: string, options?: ExecuteWithTimeout): Promise<void>;
-    /**
-     * Checks if specified method is supported by current component.
-     */
-    supports: SupportsFunc<'delete' | 'get' | 'getKeys' | 'set'>;
 }

package/dist/dts/components/CloudStorage/initCloudStorage.d.ts

@@ -0,0 +1,7 @@
+import { CloudStorage } from './CloudStorage.js';
+
+/**
+ * @returns A new initialized instance of the `CloudStorage` class.
+ * @see CloudStorage
+ */
+export declare const initCloudStorage: import('../../index.js').InitComponentFn<"version", CloudStorage, never>;

package/dist/dts/components/{haptic-feedback → HapticFeedback}/HapticFeedback.d.ts

@@ -1,15 +1,15 @@
-import type { ImpactHapticFeedbackStyle, NotificationHapticFeedbackType } from '../../bridge/methods/haptic.js';
-import type { PostEvent } from '../../bridge/methods/postEvent.js';
-import type { SupportsFunc } from '../../supports/types.js';
-import type { Version } from '../../version/types.js';
+import { WithSupports } from '../../classes/WithSupports.js';
+import { PostEvent } from '../../bridge/methods/postEvent.js';
+import { ImpactHapticFeedbackStyle, NotificationHapticFeedbackType } from '../../bridge/methods/types/haptic.js';
+import { Version } from '../../version/types.js';
+
 /**
- * Class which controls haptic feedback. It allows calling different types of
- * haptic notifications which usually occur after user interaction with
- * application.
+ * @see Usage: https://docs.telegram-mini-apps.com/platform/haptic-feedback
+ * @see API: https://docs.telegram-mini-apps.com/packages/tma-js-sdk/components/haptic-feedback
  */
-export declare class HapticFeedback {
+export declare class HapticFeedback extends WithSupports<'impactOccurred' | 'notificationOccurred' | 'selectionChanged'> {
     private readonly postEvent;
-    constructor(version: Version, postEvent?: PostEvent);
+    constructor(version: Version, postEvent: PostEvent);
     /**
      * A method tells that an impact occurred. The Telegram app may play the
      * appropriate haptics based on style value passed.
@@ -31,8 +31,4 @@ export declare class HapticFeedback {
      * use it only when the selection changes.
      */
     selectionChanged(): void;
-    /**
-     * Checks if specified method is supported by current component.
-     */
-    supports: SupportsFunc<'impactOccurred' | 'notificationOccurred' | 'selectionChanged'>;
 }

package/dist/dts/components/HapticFeedback/initHapticFeedback.d.ts

@@ -0,0 +1,7 @@
+import { HapticFeedback } from './HapticFeedback.js';
+
+/**
+ * @returns A new initialized instance of the `HapticFeedback` class.
+ * @see HapticFeedback
+ */
+export declare const initHapticFeedback: import('../../index.js').InitComponentFn<"version", HapticFeedback, never>;

package/dist/dts/components/{init-data → InitData}/InitData.d.ts

@@ -1,6 +1,8 @@
-import type { Chat, ChatType, InitDataParsed, User } from './types.js';
+import { Chat, ChatType, InitDataParsed, User } from './types.js';
+
 /**
- * Class which is responsible for displaying Mini Apps init data.
+ * @see Usage: https://docs.telegram-mini-apps.com/platform/init-data
+ * @see API: https://docs.telegram-mini-apps.com/packages/tma-js-sdk/init-data
  */
 export declare class InitData {
     private readonly initData;

package/dist/dts/components/InitData/initInitData.d.ts

@@ -0,0 +1,7 @@
+import { InitData } from './InitData.js';
+
+/**
+ * @returns A new initialized instance of the `InitData` class or undefined.
+ * @see InitData
+ */
+export declare const initInitData: import('../../index.js').InitComponentFn<"initData", InitData | undefined, never>;

package/dist/dts/components/{init-data → InitData}/parseInitData.d.ts

@@ -1,4 +1,5 @@
-import type { InitDataParsed } from './types.js';
+import { InitDataParsed } from './types.js';
+
 /**
  * Parses incoming value as init data.
  * @param value - value to parse.