declare module 'apps-sdk' {
    import { Component } from 'react';
    import { SpeechResultsEvent } from "@react-native-voice/voice";

    export interface SessionData {
        app: {
            shortVersion: string;
            package: string;
            languageCode: string;
            regionCode: string;
            buildVersionNumber: string;
        };
        device: {
            name: string;
            systemName: string;
            systemVersion: string;
            model: string;
        };
        sandbox: {
            "domains": string;
        };
        adjust: any;
        dev: boolean;
        lowPower: boolean;
        lang: string;
        package: string;
    }

    export class Session {
        sessionData: any;
        sessionID: string | null;
        isFirstOpen: boolean;
        isSubscribed: boolean;
        subscriptionData: any;
        isDevUser: boolean;
        forcedUpdate: boolean;
        init(): Promise<void>;
        setDebugMode(debugMode: boolean): void;
        setConfigEndpoint(endpoint: string): void;
        setUserCreateEndpoint(endpoint: string): void;
        setBaseUrl(baseUrl: string): void;
        getCredits(webappUrl: string, websiteId: string): Promise<number>;
        checkSubscriptionWebapp(webappUrl: string, websiteId: string): Promise<any>;
        getWebappBasePayload(websiteId: string, additionalData?: any): any;
        initSession(): Promise<void>;
        storeSessionStructure(): Promise<void>;
        checkFirstOpen(): Promise<void>;
        generateSessionID(): string;
        checkUserID(): Promise<string | null>;
        getSessionData(): any;
        getSessionID(): string | null;
        getIsFirstOpen(): boolean;
        getIsSubscribed(): boolean;
        getIsDevUser(): boolean;
        setIsSubscribed(isSubscribed: boolean): void;
        setSubscriptionData(subscriptionData: any): void;
        setSubscriptionID(subscriptionID: string): void;
        setIsDevUser(isDevUser: boolean): void;
        setUserID(userID: string): void;
        getUserID(): string | null;
        setAdjustIDFA(idfa: string): void;
        getAdjustIDFA(): string;
        setAdjustGoogleAdid(googleAdid: string): void;
        getAdjustGoogleAdid(): string;
        setAdjustAttributionID(attributionID: string): void;
        getAdjustAttributionID(): string;
        setAdjustAttribution(attribution: any): void;
        sendFirstOpen(): Promise<void>;
        checkSubscription(): Promise<void>;
        checkSubscription24h(): Promise<void>;
        isForcedUpdate(): boolean;
        getDeviceLanguage(): string;
        getDeviceLanguageAndRegion(): string;
        getAppVersion(): string;
    }

    export class Networking {
        executeInit(): Promise<void>;
        setToken(token: string): Promise<boolean | null>;
        request(url: string, data?: any): Promise<any>;
        setEndpoints(endpoints: any): void;
        getEndpoints(): any;
        setEvents(events: any): void;
        sendEvent(eventType: string, eventKeyword:string, eventData?: object, forceSend?: boolean): Promise<void>;
        createSubscription(data: any): Promise<boolean>;
        checkConnection(): Promise<boolean>;
        setImageCompression(compression: any): void;
        addPendingEvent(event: any): void;
        sendPendingEvents(): Promise<void>;
        clearPendingEvents(): void;
        setPayWallData(payWallData: any): void;
        getPayWallData(): any;
        getConfigExtra(): any;
        getQuickActions(): any;
    }

    export class Storage {
        storeData(key: string, value: any): Promise<void>;
        getData(key: string): Promise<any>;
        printAllKeys(): Promise<void>;
        removeData(key: string): Promise<void>;
        handleDownloadImage(url: string, filename: string): Promise<void>;
        handleShareFile(filename: string): Promise<boolean>;
        createDir(dirName: string): Promise<void>;
        handleDownloadImageToCreations(base64Image: string, fileName: string, data: object): Promise<{ directoryUri: string, fileUri: string, fileData: any }>;
        handleDownloadImageToTMP(base64Image: string, fileName: string): Promise<string>;
        getCreations(): Promise<any>;
        deleteCreation(dirName: string): Promise<void>;
        deleteAllCreations(): Promise<void>;
        handleDownloadImageToGallery(imageURI: string): Promise<string>;
        // handleRequestCameraPermission(): Promise<string>;
        handleRequestGalleryPermission(): Promise<string>;
        setTrackingPermissionGranted(value: boolean): Promise<void>;
        setTrackingPermissionFromStorage(): Promise<void>;
        selectImageFromGallery(galleryNotGrantedTitle: string, galleryNotGrantedMessage: string, cancelText:string, openSettingsText:string, maxPerPick?: number): Promise<string>;
        removeAllKeys(): Promise<void>;
        deleteTempFiles(): Promise<void>;
        compressImage(imageURI: string, maxSizeMB: number): Promise<string>;
    }

    export class Utils {
        isBase64(str: string): boolean;
        isBase64Image(str: string): boolean;
        isSpecialEvent(eventKeyword: string): boolean;
    }

    export interface RatingConfigOptions {
        /** Called when the sentiment prompt ("Are you enjoying the app?") should be shown. */
        onShowSentimentPrompt: (source: string) => void;
        /** Called when the feedback form should be shown (user said NO). */
        onShowFeedbackForm: () => void;
        /** Called to track analytics events. */
        onTrackEvent: (eventName: string, properties: Record<string, any>) => void;
        /** Optional: called after feedback text is submitted. */
        onSubmitFeedback?: (feedbackText: string) => Promise<void>;
    }

    export class Rating {
        /** Register UI callbacks. Call once on app startup after initialize(). */
        configure(options: RatingConfigOptions): void;
        /** Load persisted state from storage. Call on app startup. */
        initialize(): Promise<void>;
        /** Trigger rating flow after a successful AI interaction. */
        onAIInteractionSuccess(isUserInitiated?: boolean): Promise<void>;
        /** Trigger rating flow when credits are running low. */
        onCreditsRunningLow(currentCredits: number): Promise<void>;
        /** Trigger rating flow after user downloads or shares a result. */
        onResultDownloadedOrShared(actionType: 'download' | 'share'): Promise<void>;
        /** Directly call StoreReview.requestReview(). */
        triggerNativeRating(): Promise<void>;
        /** Call this when the user taps YES on the sentiment prompt. */
        onUserRespondedYes(): Promise<void>;
        /** Call this when the user taps NO on the sentiment prompt. */
        onUserRespondedNo(): void;
        /** Submit written feedback text. */
        submitFeedback(feedbackText: string): Promise<void>;
        /** Call when the user dismisses the feedback form without submitting. */
        onFeedbackCanceled(): void;
        /** Reset all persisted rating state (for debugging/testing). */
        reset(): Promise<void>;
        /** @deprecated Legacy method — use the new flow methods instead. */
        showRatingDialog(force?: boolean): Promise<{ success: boolean; shown: boolean; [key: string]: any }>;
    }

    export class NotificationsPush {
        initialize(): Promise<void>;
        registerForPushNotificationsAsync(): Promise<string>;
        getPushNotificationsStatus(): Promise<string>;
    }

    export class Voice {
        startRecognizing(
            onSpeechStart: () => void,
            onSpeechRecognized: () => void,
            onSpeechResults: (results: string[]) => void,
            onInactivityTimeout: () => void,
            inactivitySeconds?: number,
            onVolumeChange?: ((volumeValue: number) => void) | null,
            onNoSpeech?: (() => void) | null
        ): Promise<void>;

        stopRecognizing(): Promise<void>;
        destroyVoice(): Promise<void>;
        speak(
            message: string,
            language?: string | null,
            voice?: string | null,
            onStart?: () => void,
            onDone?: () => void,
            onError?: (error: any) => void
        ): void;
        stopSpeaking(onStop?: () => void): Promise<void>;
    }

    export interface PayWallProps {
        visible: boolean;
        onClose: () => void;
        type: string;
        keyword: string;
    }

    export class PayWall extends Component<PayWallProps, {}> {}

    export class PayWallLogic {
        initializePayWall(): Promise<void>;
        executePurchase(productID: string): Promise<void>;
        restorePurchase(): Promise<void>;
    }

    export class AdJust {
        sdkVersion: string | null;
        attribution: object;
        initialize(adjustToken?: string, sendAttributionToAdapty?: boolean): Promise<void>;
        updateAttributionInfo(): void;
        getAttributionData(): Promise<any>;
        sendAttributionData(attribution: any): Promise<void>;
        trackEventIfExist(eventKeyword: string, eventValue?: number): void;
        storeSubscription(subscriptionData: any): void;
        getAttribution(): Promise<void>;
        getAdid(): Promise<void>;
        getIdfa(): Promise<void>;
        getGoogleAdId(): Promise<void>;
        getSDKVersion(): void;
    }

    export class MixPanel {
        initialize(token?: string, trackAutomaticEvents?: boolean, useNative?: boolean, devMode?: boolean): Promise<void>;
        getDistinctID(): Promise<string>;
        trackEvent(event: string, properties?: object, forceSend?: boolean): Promise<void>;
        trackEventIfExist(eventKeyword: string, eventData?: object): Promise<void>;
        isMixpanelInitialized(): boolean;
        superProperties(properties: object): Promise<void>;
        superPropertiesAppend(properties: object): Promise<void>;
        identifyUser(userID: string): Promise<void>;
        resetUserID(): Promise<void>;
        setUserProperties(properties: any): Promise<void>;
        disableTracking(): Promise<void>;
        enableTracking(): Promise<void>;
    }

    type PaywallEventHandlers = {
        onCloseButtonPress?: () => void;
        onAndroidSystemBack?: () => void;
        onPurchaseStarted?: (product: any) => void;
        onPurchaseCompleted?: (purchaseResult: any, product: any) => void;
        onPurchaseFailed?: (error: any) => void;
        onRestoreStarted?: () => void;
        onRestoreCompleted?: (profile: any) => void;
        onRestoreFailed?: (error: any, product: any) => void;
        onProductSelected?: (productId: string) => void;
        onRenderingFailed?: (error: any) => void;
        onLoadingProductsFailed?: (error: any) => void;
        onUrlPress?: (url: string) => void;
        onCustomAction?: (action: string, data: any) => void;
    };

    type OnboardingEventHandlers = {
        onAnalytics?: (event: any, meta: any, remoteConfig?: any) => void;
        onClose?: (actionId: string, meta: any, remoteConfig?: any) => Promise<boolean> | boolean;
        onCustom?: (actionId: string, meta: any, remoteConfig?: any) => void;
        onPaywall?: (actionId: string, meta: any, remoteConfig?: any) => void;
        onStateUpdated?: (action: any, meta: any, remoteConfig?: any) => void;
        onFinishedLoading?: (meta: any, remoteConfig?: any) => void;
        onError?: (error: any, remoteConfig?: any) => void;
        onRemoteConfigLoaded?: (remoteConfig: any) => void;
        onModalDismissed?: () => void;
    };

    export interface AdaptyOnboardingProps {
        visible: boolean;
        placementID: string;
        lang: string;
        preloadedOnboarding?: any;
        loaderMaskColor?: string;  // Color of the mask that hides WebView loader (default: '#121212')
        loaderMaskDelay?: number;  // Delay in ms before showing content (default: 300ms)
        onAnalytics?: (event: any, meta: any, remoteConfig?: any) => void;
        onClose?: (actionId: string, meta: any, remoteConfig?: any) => Promise<boolean> | boolean;
        onCustom?: (actionId: string, meta: any, remoteConfig?: any) => void;
        onPaywall?: (actionId: string, meta: any, remoteConfig?: any) => void;
        onStateUpdated?: (action: any, meta: any, remoteConfig?: any) => void;
        onFinishedLoading?: (meta: any, remoteConfig?: any) => void;
        onError?: (error: any, remoteConfig?: any) => boolean | void;
        onRemoteConfigLoaded?: (remoteConfig: any) => void;
        onModalDismissed?: () => void;
    }

    export class AdaptyOnboarding extends Component<AdaptyOnboardingProps, {}> { }

    export class Adapty {
        initialize(apiKey: string): Promise<void>;
        getPaywallForPlacement(placementID: string, lang: string): Promise<any>;
        isActivated(): Promise<boolean>;
        createPaywallView(paywall: any): Promise<any>;
        showPaywall(placementID: any, lang: any, eventHandlers?: PaywallEventHandlers): Promise<void>;
        preloadPaywall(placementID: any, lang: any): Promise<any>
        showPaywallPreloaded(paywallView: any, eventHandlers?: PaywallEventHandlers): Promise<void>;
        checkPlacementExists(placementID: any, lang: any): Promise<boolean>;
        getProfile(): Promise<any>;
        updateAdjustAttributionData(attribution: any): Promise<void>;
        setAdjustIntegrationIdentifier(adjustIntegrationIdentifier: string): Promise<void>;
        setMixpanelIntegrationIdentifier(mixpanelIntegrationIdentifier: string): Promise<void>;
        setFirebaseIntegrationIdentifier(firebaseIntegrationIdentifier: string): Promise<void>;
        closePaywall(): Promise<void>;
        getOnboardingForPlacement(placementID: string, lang: string): Promise<any>;
        createOnboardingView(onboarding: any): Promise<any>;
        showOnboarding(placementID: string, lang: string, eventHandlers?: OnboardingEventHandlers): Promise<void>;
        checkOnboardingExists(placementID: string, lang: string): Promise<boolean>;
        closeOnboarding(): Promise<void>;
        showOnboardingPreloaded(onboardingView: any, eventHandlers?: OnboardingEventHandlers): Promise<void>;
        closePaywallFromView(paywallView: any): Promise<void>;
    }

    export class TrackingTransparency {
        requestTrackingTransparencyPermission(): Promise<string>;
        getAdvertisingIdentifier(): Promise<string>;
        getTrackingTransparencyPermission(): Promise<string>;
    }

    export class HomeActions {
        setItems(items: any): Promise<void>;
        itemCallback(itemCallbackFunction: any): Promise<void>;
    }

    export class Facebook {
        initialize(appId?: string, clientToken?: string, debugMode?: boolean, devMode?: boolean): Promise<void>;
        trackEvent(eventName: string, properties?: object): Promise<void>;
        trackEventIfExist(eventKeyword: string, eventData?: object): Promise<void>;
        trackPurchase(valueToSum: number, currency: string, parameters?: object): Promise<void>;
        trackStartTrial(parameters?: object): Promise<void>;
        trackPushNotificationOpen(payload?: object): Promise<void>;
        isFacebookInitialized(): boolean;
        getApplicationId(): string | null;
    }

    export class Legal {
        getLegalText(web_id: string, type: 'tc' | 'contact' | 'privacy_policy' | 'refund_policy' | 'faqs', lang: string): Promise<any>;
    }

    export class Firebase {
        initialize(): Promise<void>;
        getAppInstanceId(): Promise<string | null>;
        logEvent(eventName: string, params?: object): Promise<void>;
        setUserId(userId: string): Promise<void>;
        setUserProperty(name: string, value: string): Promise<void>;
    }

    // ─── Authentication ────────────────────────────────────────────────────────

    export interface AuthApiResult<T = any> {
        success: boolean;
        data?: T;
        error?: string;
        code?: number;
        message?: string;
        raw?: any;
    }

    export interface AuthLoginPayload {
        /** Email or username */
        login?: string;
        /** Credential (alias for login) */
        credential?: string;
        /** Password */
        password: string;
        /** Optional website ID (defaults to config value) */
        websiteid?: string;
    }

    export interface AuthRegisterPayload {
        /** Email or username */
        login?: string;
        /** Email (alias for login) */
        email?: string;
        /** Password */
        password: string;
        /** Optional website ID (defaults to config value) */
        websiteid?: string;
    }

    export interface AuthRegisterAndLinkPayload {
        email: string;
        password: string;
    }

    export interface AuthLinkUserPayload {
        /** Web user ID */
        user_id: string;
        /** Mobile app user ID */
        app_user_id: string;
    }

    export interface AuthCheckLinkPayload {
        user_id: string;
        app_user_id: string;
    }

    export interface AuthCheckSubscriptionPayload {
        user_id: string;
        app_user_id: string;
    }

    export interface AuthValidatePhonePayload {
        phoneNumber: string;
        countryCode: string;
    }

    export interface AuthRequestPasswordResetPayload {
        credential: string;
    }

    export interface AuthVerifyResetCodePayload {
        code: string;
    }

    export interface AuthResetPasswordPayload {
        resetToken: string;
        newPassword: string;
    }

    export interface AuthResendCodePayload {
        credential: string;
    }

    export interface AuthValidateQrCodePayload {
        qrData: string;
    }

    export interface AuthLinkWithQrCodePayload {
        user_id: string;
    }

    export interface AuthUserData {
        us_id: string | number;
        us_login?: string;
        login?: string;
        metadata?: Record<string, any> | any[];
        subscription_data?: AuthSubscriptionData;
        success?: number;
    }

    export interface AuthSubscriptionData {
        subscription_active?: boolean;
        [key: string]: any;
    }

    export interface AuthLinkedUserData {
        success: number;
        linked: boolean;
        items?: AuthUserData[];
    }

    export interface AuthRegisterAndLinkResult {
        success: boolean;
        user?: AuthUserData;
        linked?: boolean;
        error?: string;
        code?: number;
    }

    export interface AuthQrValidationData {
        valid: boolean;
        user_id?: string;
    }

    export interface AuthQrLinkData {
        linked: boolean;
        message?: string;
        subscriptionActive?: boolean;
    }

    export interface AuthCallApiOptions {
        retries?: number;
        timeoutMs?: number;
        silent?: boolean;
    }

    export class Authentication {
        AUTH_API_BASE_URL: string;
        USER_API_BASE_URL: string;
        CHATCONNECT_API_BASE_URL: string;

        /** Get website ID from config */
        getWebsiteId(): string;

        /** Get app user ID from session */
        getAppUserId(): string;

        /**
         * Generic API call helper with retry logic.
         */
        callApi(url: string, payload: object, opts?: AuthCallApiOptions): Promise<AuthApiResult>;

        /**
         * Login with credentials.
         * POST /auth/auth-user
         */
        login(payload: AuthLoginPayload): Promise<AuthApiResult<AuthUserData>>;

        /**
         * Register a new user account.
         * POST /chatconnect/create-user
         */
        register(payload: AuthRegisterPayload): Promise<AuthApiResult<{ user: AuthUserData }>>;

        /**
         * Complete registration flow: create-user → link-user.
         */
        registerAndLinkAccount(payload: AuthRegisterAndLinkPayload): Promise<AuthRegisterAndLinkResult>;

        /**
         * Link a user account.
         * POST /user/link
         */
        linkUser(payload: AuthLinkUserPayload): Promise<AuthApiResult<AuthLinkedUserData>>;

        /**
         * Fetch authenticated user profile using stored credentials.
         */
        fetchUserProfile(): Promise<AuthApiResult<AuthUserData>>;

        /**
         * Check if user account is linked (using stored data).
         */
        isAccountLinked(): Promise<boolean>;

        /**
         * Get stored auth user login (email).
         */
        getStoredUserLogin(): Promise<string | null>;

        /**
         * Check if user is linked.
         * POST /user/check-link
         */
        checkLink(payload: AuthCheckLinkPayload): Promise<AuthApiResult>;

        /**
         * Check user subscription status.
         * POST /user/check-subs
         */
        checkSubscription(payload: AuthCheckSubscriptionPayload): Promise<AuthApiResult>;

        /**
         * Check if a credential exists (stub for backward compatibility).
         */
        checkCredential(payload: { credentialType: string; [key: string]: any }): Promise<AuthApiResult<{ exists: boolean; credentialType: string; requiresPhone: boolean }>>;

        /**
         * Validate phone number (client-side).
         */
        validatePhone(payload: AuthValidatePhonePayload): Promise<AuthApiResult<{ valid: boolean; formattedPhone?: string }>>;

        /**
         * Request password reset (stub).
         */
        requestPasswordReset(payload: AuthRequestPasswordResetPayload): Promise<AuthApiResult<{ sent: boolean; destination: string; expiresIn: number }>>;

        /**
         * Verify reset code (stub).
         */
        verifyResetCode(payload: AuthVerifyResetCodePayload): Promise<AuthApiResult<{ valid: boolean; resetToken: string }>>;

        /**
         * Reset password (stub).
         */
        resetPassword(payload: AuthResetPasswordPayload): Promise<AuthApiResult<{ success: boolean; message: string }>>;

        /**
         * Resend verification code (stub).
         */
        resendCode(payload: AuthResendCodePayload): Promise<AuthApiResult<{ sent: boolean; canResendAt: string }>>;

        /**
         * Validate QR code data.
         */
        validateQrCode(payload: AuthValidateQrCodePayload): Promise<AuthApiResult<AuthQrValidationData>>;

        /**
         * Link account using QR code.
         * POST /user/link
         */
        linkWithQrCode(payload: AuthLinkWithQrCodePayload): Promise<AuthApiResult<AuthQrLinkData>>;

        /**
         * Logout current user (clears stored auth data).
         */
        logout(): Promise<AuthApiResult<{ success: boolean }>>;

        /**
         * Check if user is currently authenticated (has stored user ID).
         */
        isAuthenticated(): Promise<boolean>;

        /**
         * Get stored user ID.
         */
        getStoredUserId(): Promise<string | null>;

        /**
         * Get stored user metadata.
         */
        getStoredUserMetadata(): Promise<Record<string, any> | null>;

        /**
         * Get stored subscription data.
         */
        getStoredSubscription(): Promise<AuthSubscriptionData | null>;
    }

    export class AppsSDK {
        initializePushNotifications(): Promise<string>;
    }

    export interface AppsSDK {
        initializePushNotifications(): Promise<string>;
        getPushNotificationsStatus(): Promise<string>;
        networking          : Networking;
        storage             : Storage;
        session             : Session;
        utils               : Utils;
        paywall             : PayWall;
        adaptyOnboarding    : typeof AdaptyOnboarding;
        rating              : Rating;
        adjust              : AdJust;
        mixpanel            : MixPanel;
        tracking            : TrackingTransparency;
        paywallLogic        : PayWallLogic;
        /** @deprecated Use `notifications` instead */
        notificationsPush   : NotificationsPush;
        notifications       : NotificationsPush;
        voice               : Voice;
        adapty              : Adapty;
        homeActions         : HomeActions;
        facebook            : Facebook;
        firebase            : Firebase;
        legal               : Legal;
        authentication      : Authentication;
    }

    const Core: AppsSDK;
    export default Core;
}