@worldcoin/minikit-js 1.9.11 → 2.0.0-dev.0

package/build/types-CKn5C-Ro.d.ts

@@ -0,0 +1,220 @@
+type EventPayload = any;
+type EventHandler<E extends ResponseEvent = ResponseEvent> = (data: EventPayload) => void;
+declare class EventManager {
+    private listeners;
+    subscribe<E extends ResponseEvent>(event: E, handler: EventHandler<E>): void;
+    unsubscribe(event: ResponseEvent): void;
+    trigger(event: ResponseEvent, payload: EventPayload): void;
+}
+
+type User = {
+    walletAddress?: string;
+    username?: string;
+    profilePictureUrl?: string;
+    permissions?: {
+        notifications: boolean;
+        contacts: boolean;
+    };
+    optedIntoOptionalAnalytics?: boolean;
+};
+type DeviceProperties = {
+    safeAreaInsets?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    deviceOS?: string;
+    worldAppVersion?: number;
+};
+type UserNameService = {
+    walletAddress: string;
+    username?: string;
+    profilePictureUrl?: string;
+};
+type MiniAppLocation = {
+    countryCode?: string;
+    regionCode?: string;
+};
+declare enum MiniAppLaunchLocation {
+    Chat = "chat",
+    Home = "home",
+    AppStore = "app-store",
+    DeepLink = "deep-link",
+    WalletTab = "wallet-tab"
+}
+declare enum MiniKitInstallErrorCodes {
+    Unknown = "unknown",
+    AlreadyInstalled = "already_installed",
+    OutsideOfWorldApp = "outside_of_worldapp",
+    NotOnClient = "not_on_client",
+    AppOutOfDate = "app_out_of_date"
+}
+declare const MiniKitInstallErrorMessage: {
+    unknown: string;
+    already_installed: string;
+    outside_of_worldapp: string;
+    not_on_client: string;
+    app_out_of_date: string;
+};
+type MiniKitInstallReturnType = {
+    success: true;
+} | {
+    success: false;
+    errorCode: MiniKitInstallErrorCodes;
+    errorMessage: (typeof MiniKitInstallErrorMessage)[MiniKitInstallErrorCodes];
+};
+
+declare enum Command {
+    Pay = "pay",
+    WalletAuth = "wallet-auth",
+    SendTransaction = "send-transaction",
+    SignMessage = "sign-message",
+    SignTypedData = "sign-typed-data",
+    ShareContacts = "share-contacts",
+    RequestPermission = "request-permission",
+    GetPermissions = "get-permissions",
+    SendHapticFeedback = "send-haptic-feedback",
+    Share = "share",
+    Chat = "chat"
+}
+declare enum ResponseEvent {
+    MiniAppPayment = "miniapp-payment",
+    MiniAppWalletAuth = "miniapp-wallet-auth",
+    MiniAppSendTransaction = "miniapp-send-transaction",
+    MiniAppSignMessage = "miniapp-sign-message",
+    MiniAppSignTypedData = "miniapp-sign-typed-data",
+    MiniAppShareContacts = "miniapp-share-contacts",
+    MiniAppRequestPermission = "miniapp-request-permission",
+    MiniAppGetPermissions = "miniapp-get-permissions",
+    MiniAppSendHapticFeedback = "miniapp-send-haptic-feedback",
+    MiniAppShare = "miniapp-share",
+    MiniAppMicrophone = "miniapp-microphone",
+    MiniAppChat = "miniapp-chat"
+}
+declare const COMMAND_VERSIONS: Record<Command, number>;
+declare function isCommandAvailable(command: Command | string): boolean;
+declare function setCommandAvailable(command: Command, available: boolean): void;
+declare function validateCommands(worldAppSupportedCommands: NonNullable<typeof window.WorldApp>['supported_commands']): boolean;
+interface CommandState {
+    deviceProperties: DeviceProperties;
+}
+interface CommandContext {
+    events: EventManager;
+    state: CommandState;
+}
+type WebViewBasePayload = {
+    command: Command;
+    version: number;
+    payload: Record<string, any>;
+};
+declare function sendMiniKitEvent<T extends Record<string, any>>(payload: T): void;
+type MiniAppBaseSuccessPayload = {
+    status: 'success';
+    version: number;
+};
+type MiniAppBaseErrorPayload<TErrorCode = string> = {
+    status: 'error';
+    error_code: TErrorCode;
+    version: number;
+};
+declare function isInWorldApp(): boolean;
+type CommandVia = 'minikit' | 'wagmi' | 'fallback';
+interface CommandResult<T> {
+    data: T;
+    executedWith: CommandVia;
+}
+type CommandResultByVia<TNative, TFallback = TNative, TViaNative extends CommandVia = Exclude<CommandVia, 'fallback'>> = {
+    executedWith: TViaNative;
+    data: TNative;
+} | {
+    executedWith: 'fallback';
+    data: TFallback;
+};
+interface FallbackConfig<TFallback = unknown> {
+    /**
+     * Optional custom fallback executor.
+     * The fallback return type can differ from the native/Wagmi success payload.
+     */
+    fallback?: () => Promise<TFallback> | TFallback;
+}
+type FallbackReason = 'notInWorldApp' | 'commandNotSupported' | 'oldAppVersion';
+declare class FallbackRequiredError extends Error {
+    constructor(command: string);
+}
+declare class CommandUnavailableError extends Error {
+    readonly reason: FallbackReason;
+    constructor(command: string, reason: FallbackReason);
+}
+
+/** @deprecated Use {@link MiniKitWalletAuthOptions} instead */
+type WalletAuthInput = {
+    nonce: string;
+    statement?: string;
+    requestId?: string;
+    expirationTime?: Date;
+    notBefore?: Date;
+};
+type WalletAuthPayload = {
+    siweMessage: string;
+};
+declare enum WalletAuthErrorCodes {
+    MalformedRequest = "malformed_request",
+    UserRejected = "user_rejected",
+    GenericError = "generic_error"
+}
+declare const WalletAuthErrorMessage: {
+    malformed_request: string;
+    user_rejected: string;
+    generic_error: string;
+};
+type MiniAppWalletAuthSuccessPayload = MiniAppBaseSuccessPayload & {
+    message: string;
+    signature: string;
+    address: string;
+};
+type MiniAppWalletAuthErrorPayload = MiniAppBaseErrorPayload<WalletAuthErrorCodes> & {
+    details: (typeof WalletAuthErrorMessage)[WalletAuthErrorCodes];
+};
+type MiniAppWalletAuthPayload = MiniAppWalletAuthSuccessPayload | MiniAppWalletAuthErrorPayload;
+interface MiniKitWalletAuthOptions<TCustomFallback = WalletAuthResult> extends FallbackConfig<TCustomFallback> {
+    /** Nonce for SIWE message (alphanumeric, at least 8 chars) */
+    nonce: string;
+    /** Optional statement to include in SIWE message */
+    statement?: string;
+    /** Optional request ID for tracking */
+    requestId?: string;
+    /** Optional expiration time for the SIWE message */
+    expirationTime?: Date;
+    /** Optional not-before time for the SIWE message */
+    notBefore?: Date;
+}
+interface WalletAuthResult {
+    /** Wallet address */
+    address: string;
+    /** Signed SIWE message */
+    message: string;
+    /** Signature */
+    signature: string;
+}
+type SiweMessage = {
+    scheme?: string;
+    domain: string;
+    address?: string;
+    statement?: string;
+    uri: string;
+    version: string;
+    chain_id: number;
+    nonce: string;
+    issued_at: string;
+    expiration_time?: string;
+    not_before?: string;
+    request_id?: string;
+};
+declare class WalletAuthError extends Error {
+    readonly code: string;
+    readonly details?: string;
+    constructor(code: string, details?: string);
+}
+
+export { type MiniAppWalletAuthPayload as A, WalletAuthError as B, type CommandResultByVia as C, type DeviceProperties as D, type MiniAppLocation as E, type FallbackConfig as F, MiniKitInstallErrorCodes as G, MiniKitInstallErrorMessage as H, type MiniKitWalletAuthOptions as M, ResponseEvent as R, type SiweMessage as S, type User as U, type WalletAuthResult as W, MiniAppLaunchLocation as a, type MiniKitInstallReturnType as b, type UserNameService as c, type CommandContext as d, Command as e, COMMAND_VERSIONS as f, isCommandAvailable as g, type CommandState as h, isInWorldApp as i, type WebViewBasePayload as j, sendMiniKitEvent as k, type MiniAppBaseSuccessPayload as l, type MiniAppBaseErrorPayload as m, type CommandVia as n, type CommandResult as o, type FallbackReason as p, FallbackRequiredError as q, CommandUnavailableError as r, setCommandAvailable as s, type WalletAuthInput as t, type WalletAuthPayload as u, validateCommands as v, WalletAuthErrorCodes as w, WalletAuthErrorMessage as x, type MiniAppWalletAuthSuccessPayload as y, type MiniAppWalletAuthErrorPayload as z };

package/build/types-DO2UGrgp.d.cts

@@ -0,0 +1,438 @@
+import { F as FallbackConfig, l as MiniAppBaseSuccessPayload, m as MiniAppBaseErrorPayload } from './types-CKn5C-Ro.cjs';
+import { Abi, AbiStateMutability, ExtractAbiFunctionNames, AbiParametersToPrimitiveTypes, ExtractAbiFunction, TypedData, TypedDataDomain } from 'abitype';
+
+type ChatParams = {
+    to?: string[];
+    message: string;
+};
+/** @deprecated Use {@link MiniKitChatOptions} instead */
+type ChatInput = ChatParams;
+interface MiniKitChatOptions<TCustomFallback = MiniAppChatPayload> extends ChatParams, FallbackConfig<TCustomFallback> {
+}
+declare enum ChatErrorCodes {
+    UserRejected = "user_rejected",
+    SendFailed = "send_failed",
+    GenericError = "generic_error"
+}
+type MiniAppChatSuccessPayload = MiniAppBaseSuccessPayload & {
+    count: number;
+    timestamp: string;
+};
+type MiniAppChatErrorPayload = MiniAppBaseErrorPayload<ChatErrorCodes>;
+type MiniAppChatPayload = MiniAppChatSuccessPayload | MiniAppChatErrorPayload;
+declare class ChatError extends Error {
+    readonly error_code: ChatErrorCodes;
+    constructor(error_code: ChatErrorCodes);
+}
+
+declare enum GetPermissionsErrorCodes {
+    GenericError = "generic_error"
+}
+declare enum Permission {
+    Notifications = "notifications",
+    Contacts = "contacts",
+    Microphone = "microphone"
+}
+type PermissionSettings = {
+    [K in Permission]?: any;
+};
+type MiniAppGetPermissionsSuccessPayload = MiniAppBaseSuccessPayload & {
+    permissions: PermissionSettings;
+    timestamp: string;
+};
+type MiniAppGetPermissionsErrorPayload = MiniAppBaseErrorPayload<GetPermissionsErrorCodes> & {
+    details: string;
+};
+type MiniAppGetPermissionsPayload = MiniAppGetPermissionsSuccessPayload | MiniAppGetPermissionsErrorPayload;
+interface MiniKitGetPermissionsOptions<TCustomFallback = MiniAppGetPermissionsPayload> extends FallbackConfig<TCustomFallback> {
+}
+declare class GetPermissionsError extends Error {
+    readonly error_code: GetPermissionsErrorCodes;
+    constructor(error_code: GetPermissionsErrorCodes);
+}
+
+declare enum Tokens {
+    USDC = "USDCE",
+    WLD = "WLD"
+}
+declare const TokenDecimals: {
+    [key in Tokens]: number;
+};
+declare enum Network {
+    Optimism = "optimism",
+    WorldChain = "worldchain"
+}
+type TokensPayload = {
+    symbol: Tokens;
+    token_amount: string;
+};
+/** @deprecated Use {@link MiniKitPayOptions} instead */
+type PayCommandInput = {
+    reference: string;
+    to: `0x${string}` | string;
+    tokens: TokensPayload[];
+    network?: Network;
+    description: string;
+};
+/** @deprecated Use {@link MiniKitPayOptions} instead */
+type PayCommandPayload = PayCommandInput;
+declare enum PaymentErrorCodes {
+    InputError = "input_error",
+    UserRejected = "user_rejected",
+    PaymentRejected = "payment_rejected",
+    InvalidReceiver = "invalid_receiver",
+    InsufficientBalance = "insufficient_balance",
+    TransactionFailed = "transaction_failed",
+    GenericError = "generic_error",
+    UserBlocked = "user_blocked"
+}
+declare const PaymentErrorMessage: Record<PaymentErrorCodes, string>;
+type MiniAppPaymentSuccessPayload = MiniAppBaseSuccessPayload & {
+    transaction_status: 'submitted';
+    transaction_id: string;
+    reference: string;
+    from: string;
+    chain: Network;
+    timestamp: string;
+};
+type MiniAppPaymentErrorPayload = MiniAppBaseErrorPayload<PaymentErrorCodes>;
+type MiniAppPaymentPayload = MiniAppPaymentSuccessPayload | MiniAppPaymentErrorPayload;
+interface MiniKitPayOptions<TCustomFallback = PayResult> extends FallbackConfig<TCustomFallback> {
+    /** Unique reference for this payment (for tracking) */
+    reference: string;
+    /** Recipient address */
+    to: `0x${string}` | string;
+    /** Token(s) and amount(s) to send */
+    tokens: TokensPayload[];
+    /** Payment description shown to user */
+    description: string;
+    /** Network (defaults to World Chain) */
+    network?: Network;
+}
+interface PayResult {
+    /** Transaction hash/ID */
+    transactionId: string;
+    /** Reference that was passed in */
+    reference: string;
+    /** From address */
+    from: string;
+    /** Chain used */
+    chain: Network;
+    /** Timestamp */
+    timestamp: string;
+}
+declare class PayError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+
+type RequestPermissionParams = {
+    permission: Permission;
+};
+/** @deprecated Use {@link MiniKitRequestPermissionOptions} instead */
+type RequestPermissionInput = RequestPermissionParams;
+declare enum RequestPermissionErrorCodes {
+    UserRejected = "user_rejected",
+    GenericError = "generic_error",
+    AlreadyRequested = "already_requested",
+    PermissionDisabled = "permission_disabled",
+    AlreadyGranted = "already_granted",
+    UnsupportedPermission = "unsupported_permission"
+}
+type MiniAppRequestPermissionSuccessPayload = MiniAppBaseSuccessPayload & {
+    permission: Permission;
+    timestamp: string;
+};
+type MiniAppRequestPermissionErrorPayload = MiniAppBaseErrorPayload<RequestPermissionErrorCodes> & {
+    description: string;
+};
+type MiniAppRequestPermissionPayload = MiniAppRequestPermissionSuccessPayload | MiniAppRequestPermissionErrorPayload;
+interface MiniKitRequestPermissionOptions<TCustomFallback = MiniAppRequestPermissionPayload> extends RequestPermissionParams, FallbackConfig<TCustomFallback> {
+}
+declare class RequestPermissionError extends Error {
+    readonly error_code: RequestPermissionErrorCodes;
+    constructor(error_code: RequestPermissionErrorCodes);
+}
+
+type SendHapticFeedbackParams = {
+    hapticsType: 'notification';
+    style: 'error' | 'success' | 'warning';
+} | {
+    hapticsType: 'selection-changed';
+    style?: never;
+} | {
+    hapticsType: 'impact';
+    style: 'light' | 'medium' | 'heavy';
+};
+/** @deprecated Use {@link MiniKitSendHapticFeedbackOptions} instead */
+type SendHapticFeedbackInput = SendHapticFeedbackParams;
+declare enum SendHapticFeedbackErrorCodes {
+    GenericError = "generic_error",
+    UserRejected = "user_rejected"
+}
+type MiniAppSendHapticFeedbackSuccessPayload = MiniAppBaseSuccessPayload & {
+    timestamp: string;
+};
+type MiniAppSendHapticFeedbackErrorPayload = MiniAppBaseErrorPayload<SendHapticFeedbackErrorCodes>;
+type MiniAppSendHapticFeedbackPayload = MiniAppSendHapticFeedbackSuccessPayload | MiniAppSendHapticFeedbackErrorPayload;
+type MiniKitSendHapticFeedbackOptions<TCustomFallback = MiniAppSendHapticFeedbackPayload> = SendHapticFeedbackParams & FallbackConfig<TCustomFallback>;
+declare class SendHapticFeedbackError extends Error {
+    readonly error_code: SendHapticFeedbackErrorCodes;
+    constructor(error_code: SendHapticFeedbackErrorCodes);
+}
+
+type Permit2 = {
+    permitted: {
+        token: string;
+        amount: string | unknown;
+    };
+    spender: string;
+    nonce: string | unknown;
+    deadline: string | unknown;
+};
+type Transaction = {
+    address: string;
+    value?: string | undefined;
+    /** Raw calldata. If provided, it takes precedence over ABI/functionName/args. */
+    data?: string;
+    abi?: Abi | readonly unknown[];
+    functionName?: ContractFunctionName<Abi | readonly unknown[], 'payable' | 'nonpayable'>;
+    args?: ContractFunctionArgs<Abi | readonly unknown[], 'payable' | 'nonpayable', ContractFunctionName<Abi | readonly unknown[], 'payable' | 'nonpayable'>>;
+};
+type ContractFunctionName<abi extends Abi | readonly unknown[] = Abi, mutability extends AbiStateMutability = AbiStateMutability> = ExtractAbiFunctionNames<abi extends Abi ? abi : Abi, mutability> extends infer functionName extends string ? [functionName] extends [never] ? string : functionName : string;
+type ContractFunctionArgs<abi extends Abi | readonly unknown[] = Abi, mutability extends AbiStateMutability = AbiStateMutability, functionName extends ContractFunctionName<abi, mutability> = ContractFunctionName<abi, mutability>> = AbiParametersToPrimitiveTypes<ExtractAbiFunction<abi extends Abi ? abi : Abi, functionName, mutability>['inputs'], 'inputs'> extends infer args ? [args] extends [never] ? readonly unknown[] : args : readonly unknown[];
+/** @deprecated Use {@link MiniKitSendTransactionOptions} instead */
+type SendTransactionInput = {
+    transaction: Transaction[];
+    permit2?: Permit2[];
+    formatPayload?: boolean;
+};
+/** @deprecated Use {@link MiniKitSendTransactionOptions} instead */
+type SendTransactionPayload = SendTransactionInput;
+declare enum SendTransactionErrorCodes {
+    InvalidOperation = "invalid_operation",
+    UserRejected = "user_rejected",
+    InputError = "input_error",
+    SimulationFailed = "simulation_failed",
+    TransactionFailed = "transaction_failed",
+    GenericError = "generic_error",
+    DisallowedOperation = "disallowed_operation",
+    ValidationError = "validation_error",
+    InvalidContract = "invalid_contract",
+    MaliciousOperation = "malicious_operation",
+    DailyTxLimitReached = "daily_tx_limit_reached",
+    PermittedAmountExceedsSlippage = "permitted_amount_exceeds_slippage",
+    PermittedAmountNotFound = "permitted_amount_not_found"
+}
+declare const SendTransactionErrorMessage: Record<SendTransactionErrorCodes, string>;
+type MiniAppSendTransactionSuccessPayload = MiniAppBaseSuccessPayload & {
+    transaction_status: 'submitted';
+    transaction_id: string;
+    reference?: string;
+    from: string;
+    chain: Network;
+    timestamp: string;
+    userOpHash?: string;
+    mini_app_id?: string;
+};
+type MiniAppSendTransactionErrorPayload = MiniAppBaseErrorPayload<SendTransactionErrorCodes> & {
+    details?: Record<string, any>;
+    mini_app_id?: string;
+};
+type MiniAppSendTransactionPayload = MiniAppSendTransactionSuccessPayload | MiniAppSendTransactionErrorPayload;
+interface MiniKitSendTransactionOptions<TCustomFallback = SendTransactionResult> extends FallbackConfig<TCustomFallback> {
+    /** Transactions to execute */
+    transaction: Transaction[];
+    /**
+     * Optional chain ID to execute on.
+     * - World App currently only supports World Chain (480).
+     * - On web (wagmi fallback), this is forwarded to wagmi.
+     */
+    chainId?: number;
+    /** Permit2 data for token approvals (World App only) */
+    permit2?: Permit2[];
+    /** Whether to format the payload (default: true) */
+    formatPayload?: boolean;
+}
+interface SendTransactionResult {
+    /** On-chain transaction hash (Wagmi fallback) */
+    transactionHash?: string | null;
+    /** User operation hash (World App only) */
+    userOpHash?: string | null;
+    /** Mini App ID (World App only) */
+    mini_app_id?: string | null;
+    /** Result status */
+    status?: 'success' | null;
+    /** Payload version */
+    version?: number | null;
+    /** Transaction ID (World App only) */
+    transactionId?: string | null;
+    /** Reference (World App only) */
+    reference?: string | null;
+    /** From address */
+    from?: string | null;
+    /** Chain identifier */
+    chain?: string | null;
+    /** Timestamp */
+    timestamp?: string | null;
+    /** @deprecated Use `transactionId` instead */
+    transaction_id?: string | null;
+    /** @deprecated Success is implicit (errors throw). Always `'submitted'` when present. */
+    transaction_status?: 'submitted';
+}
+interface FeatureSupport {
+    /** Whether batch transactions are supported */
+    batch: boolean;
+    /** Whether Permit2 is supported */
+    permit2: boolean;
+    /** Whether gas sponsorship is available */
+    gasSponsorship: boolean;
+}
+declare const WORLD_APP_FEATURES: FeatureSupport;
+declare const WEB_FEATURES: FeatureSupport;
+declare class SendTransactionError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(code: string, details?: Record<string, unknown>);
+}
+
+type ShareParams = {
+    files?: File[];
+    title?: string;
+    text?: string;
+    url?: string;
+};
+/** @deprecated Use {@link MiniKitShareOptions} instead */
+type ShareInput = ShareParams;
+interface MiniKitShareOptions<TCustomFallback = MiniAppSharePayload> extends ShareParams, FallbackConfig<TCustomFallback> {
+}
+type SharePayload = {
+    files?: Array<{
+        name: string;
+        type: string;
+        data: string;
+    }>;
+    title?: string;
+    text?: string;
+    url?: string;
+};
+declare enum ShareFilesErrorCodes {
+    UserRejected = "user_rejected",
+    GenericError = "generic_error",
+    InvalidFileName = "invalid_file_name"
+}
+type MiniAppShareSuccessPayload = MiniAppBaseSuccessPayload & {
+    shared_files_count: number;
+    timestamp: string;
+};
+type MiniAppShareErrorPayload = MiniAppBaseErrorPayload<ShareFilesErrorCodes>;
+type MiniAppSharePayload = MiniAppShareSuccessPayload | MiniAppShareErrorPayload;
+declare class ShareError extends Error {
+    readonly error_code: ShareFilesErrorCodes;
+    constructor(error_code: ShareFilesErrorCodes);
+}
+
+type ShareContactsParams = {
+    isMultiSelectEnabled: boolean;
+    inviteMessage?: string;
+};
+/** @deprecated Use {@link MiniKitShareContactsOptions} instead */
+type ShareContactsInput = ShareContactsParams;
+/** @deprecated Use {@link MiniKitShareContactsOptions} instead */
+type ShareContactsPayload = ShareContactsInput;
+declare enum ShareContactsErrorCodes {
+    UserRejected = "user_rejected",
+    GenericError = "generic_error"
+}
+declare const ShareContactsErrorMessage: {
+    user_rejected: string;
+    generic_error: string;
+};
+type Contact = {
+    username: string;
+    walletAddress: string;
+    profilePictureUrl: string | null;
+};
+type MiniAppShareContactsSuccessPayload = MiniAppBaseSuccessPayload & {
+    contacts: Contact[];
+    timestamp: string;
+};
+type MiniAppShareContactsErrorPayload = MiniAppBaseErrorPayload<ShareContactsErrorCodes>;
+type MiniAppShareContactsPayload = MiniAppShareContactsSuccessPayload | MiniAppShareContactsErrorPayload;
+interface MiniKitShareContactsOptions<TCustomFallback = ShareContactsResult> extends FallbackConfig<TCustomFallback> {
+    /** Enable multi-select in the contact picker */
+    isMultiSelectEnabled?: boolean;
+    /** Custom invite message for sharing */
+    inviteMessage?: string;
+}
+interface ShareContactsResult {
+    /** Selected contacts */
+    contacts: Contact[];
+    /** Timestamp */
+    timestamp: string;
+}
+declare class ShareContactsError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+
+type SignMessageParams = {
+    message: string;
+};
+/** @deprecated Use {@link MiniKitSignMessageOptions} instead */
+type SignMessageInput = SignMessageParams;
+interface MiniKitSignMessageOptions<TCustomFallback = MiniAppSignMessageSuccessPayload> extends SignMessageParams, FallbackConfig<TCustomFallback> {
+}
+declare enum SignMessageErrorCodes {
+    InvalidMessage = "invalid_message",
+    UserRejected = "user_rejected",
+    GenericError = "generic_error"
+}
+type MiniAppSignMessageSuccessPayload = MiniAppBaseSuccessPayload & {
+    signature: string;
+    address: string;
+};
+type MiniAppSignMessageErrorPayload = MiniAppBaseErrorPayload<SignMessageErrorCodes> & {
+    details?: Record<string, any>;
+};
+type MiniAppSignMessagePayload = MiniAppSignMessageSuccessPayload | MiniAppSignMessageErrorPayload;
+declare class SignMessageError extends Error {
+    readonly error_code: SignMessageErrorCodes;
+    constructor(error_code: SignMessageErrorCodes);
+}
+
+type SignTypedDataParams = {
+    types: TypedData;
+    primaryType: string;
+    message: Record<string, unknown>;
+    domain?: TypedDataDomain;
+    chainId?: number;
+};
+/** @deprecated Use {@link MiniKitSignTypedDataOptions} instead */
+type SignTypedDataInput = SignTypedDataParams;
+interface MiniKitSignTypedDataOptions<TCustomFallback = MiniAppSignTypedDataPayload> extends SignTypedDataParams, FallbackConfig<TCustomFallback> {
+}
+declare enum SignTypedDataErrorCodes {
+    InvalidOperation = "invalid_operation",
+    UserRejected = "user_rejected",
+    InputError = "input_error",
+    SimulationFailed = "simulation_failed",
+    GenericError = "generic_error",
+    DisallowedOperation = "disallowed_operation",
+    InvalidContract = "invalid_contract",
+    MaliciousOperation = "malicious_operation"
+}
+type MiniAppSignTypedDataSuccessPayload = MiniAppBaseSuccessPayload & {
+    signature: string;
+    address: string;
+};
+type MiniAppSignTypedDataErrorPayload = MiniAppBaseErrorPayload<SignTypedDataErrorCodes> & {
+    details?: Record<string, any>;
+};
+type MiniAppSignTypedDataPayload = MiniAppSignTypedDataSuccessPayload | MiniAppSignTypedDataErrorPayload;
+declare class SignTypedDataError extends Error {
+    readonly error_code: SignTypedDataErrorCodes;
+    constructor(error_code: SignTypedDataErrorCodes);
+}
+
+export { type MiniAppSendHapticFeedbackErrorPayload as $, Permission as A, type PermissionSettings as B, type ChatInput as C, type MiniAppGetPermissionsErrorPayload as D, GetPermissionsError as E, TokenDecimals as F, GetPermissionsErrorCodes as G, type TokensPayload as H, type PayCommandInput as I, type PayCommandPayload as J, PaymentErrorCodes as K, PaymentErrorMessage as L, type MiniKitSendTransactionOptions as M, Network as N, type MiniAppPaymentSuccessPayload as O, type PayResult as P, type MiniAppPaymentErrorPayload as Q, type MiniAppPaymentPayload as R, type SendTransactionResult as S, Tokens as T, PayError as U, type RequestPermissionInput as V, RequestPermissionErrorCodes as W, type MiniAppRequestPermissionErrorPayload as X, RequestPermissionError as Y, type SendHapticFeedbackInput as Z, SendHapticFeedbackErrorCodes as _, type MiniKitPayOptions as a, SendHapticFeedbackError as a0, type Permit2 as a1, type Transaction as a2, type ContractFunctionName as a3, type ContractFunctionArgs as a4, type SendTransactionInput as a5, type SendTransactionPayload as a6, SendTransactionErrorCodes as a7, SendTransactionErrorMessage as a8, type MiniAppSendTransactionSuccessPayload as a9, SignTypedDataErrorCodes as aA, type MiniAppSignTypedDataErrorPayload as aB, SignTypedDataError as aC, type MiniAppSendTransactionErrorPayload as aa, type MiniAppSendTransactionPayload as ab, type FeatureSupport as ac, WORLD_APP_FEATURES as ad, WEB_FEATURES as ae, SendTransactionError as af, type ShareInput as ag, type SharePayload as ah, ShareFilesErrorCodes as ai, type MiniAppShareErrorPayload as aj, ShareError as ak, type ShareContactsInput as al, type ShareContactsPayload as am, ShareContactsErrorCodes as an, ShareContactsErrorMessage as ao, type Contact as ap, type MiniAppShareContactsSuccessPayload as aq, type MiniAppShareContactsErrorPayload as ar, type MiniAppShareContactsPayload as as, ShareContactsError as at, type SignMessageInput as au, SignMessageErrorCodes as av, type MiniAppSignMessageErrorPayload as aw, type MiniAppSignMessagePayload as ax, SignMessageError as ay, type SignTypedDataInput as az, type ShareContactsResult as b, type MiniKitShareContactsOptions as c, type MiniAppSignMessageSuccessPayload as d, type MiniKitSignMessageOptions as e, type MiniAppSignTypedDataPayload as f, type MiniKitSignTypedDataOptions as g, type MiniAppSignTypedDataSuccessPayload as h, type MiniAppChatPayload as i, type MiniKitChatOptions as j, type MiniAppChatSuccessPayload as k, type MiniAppSharePayload as l, type MiniKitShareOptions as m, type MiniAppShareSuccessPayload as n, type MiniAppGetPermissionsPayload as o, type MiniKitGetPermissionsOptions as p, type MiniAppGetPermissionsSuccessPayload as q, type MiniAppRequestPermissionPayload as r, type MiniKitRequestPermissionOptions as s, type MiniAppRequestPermissionSuccessPayload as t, type MiniAppSendHapticFeedbackPayload as u, type MiniKitSendHapticFeedbackOptions as v, type MiniAppSendHapticFeedbackSuccessPayload as w, ChatErrorCodes as x, type MiniAppChatErrorPayload as y, ChatError as z };