import { ConnectableRaftType, RaftConnectionMethod, RaftConnectOptions, RaftTypeE } from "../../types/raft";
import WebAppCommunicator from "../../wrapper-app/communicators/WebAppCommunicator";
import RAFT from "../RAFTs/RAFT";
import Marty from "../RAFTs/Marty/Marty";
import Cog from "../RAFTs/Cog/Cog";
import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
import { ColourSensorCalibrationStage } from "../../types/colour-sensor-calibration";
import { RaftObserver } from "../RAFTs/RaftObserver";
import { RaftInfoEvents } from "../../types/events/raft-info";
import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent, RaftWifiScanResults, RaftWifiConnStatus, RaftOKFail } from "@robdobsn/raftjs";
import { ConnectedRaftItem } from "../../store/SelectedRaftContext";
import Toaster from "../../utils/Toaster";
import AnalyticsFacade from "@robotical/appv2-analytics-gatherer";
import { CarouselNavigatorManager } from "../../utils/CarouselNavigatorManager";
import { CustomBluetoothItem, UserDeviceInfo } from "../../types/userDeviceInfo";
import { UserRoleContextTypes } from "../../store/user-role-context";
type ConnectResultDisposition = "commit" | "release" | "ignore";
export default class ApplicationManager {
    selectedLocale: string;
    AnalyticsFacade: typeof AnalyticsFacade;
    analyticsSessionId: string | undefined;
    private _observers;
    static wrapperAppCommunicator: WebAppCommunicator;
    connectedRafts: {
        [key: string]: RAFT;
    };
    private _connectPromise;
    private _connectAttemptSequence;
    private _activeConnectAttemptId;
    private _disconnectPromises;
    private _pendingWifiLocators;
    connectedRaftsContext: ConnectedRaftItem[];
    returnToMainApp: () => void;
    carouselNavigatorManager: CarouselNavigatorManager;
    deviceInfo: UserDeviceInfo | undefined;
    userRoleCtx: UserRoleContextTypes | null;
    lastUUIDsUsed: string[] | null;
    setUserRoleCtx(userRoleCtx: UserRoleContextTypes): void;
    private _router;
    setRouter(router: any): void;
    navigateTo(path: string): void;
    setSelectedLocale(locale: string): void;
    getSelectedLocale(): string;
    ricSelectedCb: ((raft: RAFT) => void) | null;
    toaster: typeof Toaster;
    showBackHomeButton: () => void;
    hideBackHomeButton: () => void;
    connectedRaftContextMethods: {
        addConnectedRaft: (connectedRaft: ConnectedRaftItem) => void;
        removeConnectedRaft: (connectedRaftId: string) => void;
        setSelectedRaft: (connectedRaftId: string) => void;
        getSelectedRaft: () => {
            raftSummary: ConnectedRaftItem | undefined;
            raftEntity: RAFT | undefined;
        };
        nameUpdated: () => void;
    };
    isPhoneApp: () => boolean;
    constructor();
    getDeviceInfo(): Promise<void>;
    ensureWifiConnectionSupported(): Promise<boolean>;
    updateRaftNameInAllStates(raftId: string, name: string): Promise<boolean>;
    private getConnectedRaftName;
    /**
     * Whether this exact RAFT object still owns its ID and is not already in
     * the asynchronous disconnect pipeline.
     */
    isRaftActive(raft: RAFT): boolean;
    private addConnectedRaftToContext;
    private publishLocalVerifiedConnection;
    private confirmQrVerifiedConnection;
    private getWifiManager;
    pauseWifiConnection(raftId: string, pause: boolean): Promise<boolean>;
    getCachedWifiStatus(raftId: string): RaftWifiConnStatus | undefined;
    wifiConnect(raftId: string, ssid: string, password: string): Promise<boolean>;
    wifiDisconnect(raftId: string): Promise<boolean>;
    getWiFiConnStatus(raftId: string): Promise<boolean | null>;
    getWifiScanResults(raftId: string): Promise<RaftWifiScanResults | RaftOKFail | boolean>;
    private getMartyWifiManager;
    pauseWifiConnectionMarty(raftId: string, pause: boolean): Promise<boolean>;
    getCachedWifiStatusMarty(raftId: string): RaftWifiConnStatus | undefined;
    wifiConnectMarty(raftId: string, ssid: string, password: string): Promise<boolean>;
    wifiDisconnectMarty(raftId: string): Promise<boolean>;
    getWiFiConnStatusMarty(raftId: string): Promise<boolean | null>;
    getWifiScanResultsMarty(raftId: string): Promise<RaftWifiScanResults | RaftOKFail | boolean>;
    calibrateMarty(martyId: string, cmd: string, joints: string): Promise<false | RaftOKFail | undefined>;
    calibrateColourSensorsMarty(raftId: string, stage: ColourSensorCalibrationStage): Promise<unknown>;
    resetColourSensorOffsetsMarty(raftId: string): Promise<unknown>;
    getCommsStatsMarty(martyId: string): Promise<{
        msgRxRate: number;
        msgRoundtripWorstMs: number;
        msgRoundtripLastMs: number;
        msgRoundtripBestMs: number;
        msgRetries: number;
    }>;
    getConnectedColourSensorsMarty(martyId: string): Promise<any>;
    getConnectedAddOnsMarty(martyId: string): Promise<any>;
    getAddOnConfigsMarty(martyId: string): Promise<any>;
    identifyAddOnMarty(martyId: string, addOnSN: string): Promise<any>;
    setAddOnConfigMarty(martyId: string, addOnSN: string, config: any): Promise<any>;
    deleteAddOnMarty(martyId: string, addOnSN: string): Promise<any>;
    createNewCog(id: string): Cog;
    createNewMarty(id: string): Marty;
    connectGenericMarty(afterRaftConnectedCb: (raft: RAFT) => void, options?: RaftConnectOptions): Promise<void>;
    connectGenericCog(afterRaftConnectedCb: (raft: RAFT) => void, options?: RaftConnectOptions): Promise<void>;
    /**
     * Generic Connect method
     * This method is called from various environments (connection button, blocksjr, blocks etc.)
     * Known issue: connecting to a raft from within a platform won't add the newly connected raft to the connectedRafts hook
     */
    connectGeneric(afterRaftConnectedCb: (raft: RAFT) => void, uuids?: string[], shouldShowQrModal?: boolean, options?: RaftConnectOptions): Promise<void>;
    private _clearConnectPromise;
    private _dismissConnectAttempt;
    private _isConnectAttemptActive;
    private _getConnectResultDisposition;
    private _createConnectingModal;
    private _resolveConnectOptions;
    private _connectGeneric;
    private _connectWithResolvedOptions;
    /**
     * Disconnect from RAFT generic
     * This method is called from various environments (connection button, blocksjr, blocks etc.)
     */
    disconnectGeneric(raft: RAFT, afterRaftDisconnectedCb?: () => void, skipConfirmation?: boolean): Promise<void>;
    /**
     * Selects a RAFT in Phone's verification modal
     */
    selectRaft(ricToConnectTo: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC'], method: RaftConnectionMethod): Promise<RAFT | null>;
    connectToRIC(method: RaftConnectionMethod, uuids: string[], withoutVerification?: boolean, getResultDisposition?: () => ConnectResultDisposition, locator?: string, expectedRaftType?: ConnectableRaftType): Promise<RAFT | null>;
    /**
     * Warranty Service bluetooth scan for device
     * It scans for a device and gets the device object
     * Then it checks if the device is already in the given devices array having CustomBluetoothItem[] type
     * if not, it gets its serial number and adds it to the devices array
     * @returns {Promise<CustomBluetoothItem[]>}
     */
    scanForPotentialWarrantyDevice(existingDevices: CustomBluetoothItem[]): Promise<CustomBluetoothItem[]>;
    /**
     * Toggles the Sensors Dashboard modal
     */
    toggleSensorsDashboard(): void;
    /**
     * Disconnect from RAFT
     */
    disconnectFromRaft(raftId: string): Promise<void>;
    /**
     * Finalizes a RAFT which has already emitted its terminal disconnect event.
     * Passing the source RAFT prevents a late event from deleting a replacement
     * connection which happens to have the same serial/ID.
     */
    removeRaft(raftId: string, disconnectedRaft?: RAFT): Promise<void>;
    private _disconnectRaft;
    private _removeRaftIfCurrent;
    /**
     * Start looking for rics to connect to
     * This is used from the Phone App only
     */
    startDiscovery(ricSelectedCb: (raft: RAFT) => void, uuids: string[], expectedRaftType?: ConnectableRaftType): Promise<void>;
    /**
     * Start discovery without verification
     * This is used from the Phone App only, when the user wants to connect to a RAFT with qr code
     */
    startDiscoveryWithoutVerification(uuids: string[], afterRaftConnectedCb: (raft: RAFT) => void): Promise<void>;
    /**
     * Stοp discovery
     * When the user cancels the discovery process without having first connected to a robot
     */
    stopDiscovery(): Promise<void>;
    /**
     * Stop verifying raft
     */
    stopVerifyingRaft(raftId: string, isCorrectRIC: boolean): Promise<boolean | undefined>;
    /**
     * Publishing events to observers
     * It could be either events we get from RAFT, or custom events related to the app
     */
    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
    subscribe(observer: RaftObserver, topics: Array<string>): void;
    unsubscribe(observer: RaftObserver): void;
    receivedRICEvent(raftId: string, eventType: any, eventEnum: any, eventName: any, eventData: any): void;
    /**
     * Save the file on the device
     */
    saveFileOnDevice(fileName: string, base64: string): void | Promise<unknown>;
    /**
     * Save the file on the device's local storage
     */
    saveFileOnDeviceLocalStorage(dirname: string, fileName: string, base64: string): void | Promise<unknown>;
    /**
     * Load the file from the device's local storage
     */
    loadFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
    /**
     * Delete the file from the device's local storage
     */
    deleteFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
    /**
     * List the files from the device's local storage
     */
    listFilesFromDeviceLocalStorage(dirname: string): Promise<unknown>;
    /**
     * Injects JS code to the phone app
     * This is used to call native functions from the web app
     */
    injectJS(jsCode: string): Promise<unknown>;
    getTheCurrentlySelectedDeviceOrFirstOfItsKind(deviceType: RaftTypeE): RAFT | undefined;
}
export {};