declare type AimingMode = 'arcade' | 'strategic' | 'arty' | 'sniper' | 'postmortem' | 'debug' | 'video' | 'mapcase' | 'arcadeMapcase' | 'epicMapcase' | 'respawn' | 'deathfreecam' | 'dualgun' | 'arcadeEpicMinefieldMapcase' | 'killcam' | 'vehiclesSelection' | 'twinGun' | 'lookAtKiller';

declare type AttackReason = 'shot' | 'fire' | 'ramming' | 'world_collision' | 'death_zone' | 'drowning' | 'gas_attack' | 'overturn' | 'manual' | 'artillery_protection' | 'artillery_sector' | 'bombers' | 'recovery' | 'artillery_eq' | 'bomber_eq' | 'minefield_eq' | 'spawned_bot_explosion' | 'berserker_eq' | 'smoke' | 'corrodingShot' | 'AdaptationHealthRestore' | 'thunderStrike' | 'fireCircle' | 'clingBrander' | 'ram_cling_brander' | 'ram_brander' | 'fort_artillery_eq' | 'static_deathzone' | 'cgf_world' | 'none';

declare type BaseCaptureBlocked = {
    type: 'baseCaptureBlocked';
    data: {
        points: number;
        session: number;
    };
};

declare type BaseCaptureDropped = {
    type: 'baseCaptureDropped';
    data: {
        points: number;
    };
};

declare type BaseCapturePoints = {
    type: 'baseCapturePoints';
    data: {
        points: number;
        session: number;
    };
};

declare abstract class BaseDebugConnection {
    private frame;
    private key;
    private connected;
    private enabled;
    get isConnected(): ReadonlyWatchableValue<boolean>;
    get isEnabled(): ReadonlyWatchableValue<boolean>;
    constructor(frame: HTMLIFrameElement, key: string);
    protected onMessageFromWidget: (event: MessageEvent) => void;
    post(data: any): void;
    enable(): void;
    disable(): void;
    abstract processCommand(command: string, data: any): void;
    dispose(): void;
}

declare type ChangeStateMessage = {
    type: 'state';
    path: Path;
    value: ValueType;
};

declare type Crit = {
    type: 'crit';
    data: CriticalHitExtra;
};

declare type CriticalHitExtra = {
    critsCount: number;
    attackReason: AttackReason;
    secondaryReason: AttackReason;
    shellType: ShellType;
    vehicle: VehicleWithOwner;
};

declare type CritVariant = {
    type: 'DESTROYED_DEVICES';
    value: typeof VEHICLE_DEVICE_TYPE_NAMES[number];
} | {
    type: 'CRITICAL_DEVICES';
    value: typeof VEHICLE_DEVICE_TYPE_NAMES[number];
} | {
    type: 'DESTROYED_TANKMENS';
    value: typeof VEHICLE_TANKMAN_TYPE_NAMES[number];
};

declare type Damage = {
    type: 'damage';
    data: DamageExtra;
};

declare type DamageExtra = {
    damage: number;
    attackReason: AttackReason;
    secondaryReason: AttackReason;
    shellType: ShellType;
    vehicle: VehicleWithOwner;
};

declare type DeepProxy<T> = {
    [P in keyof T]: T[P] extends State<infer _> ? T[P] : T[P] extends Trigger<infer _> ? T[P] : DeepProxy<T[P]>;
};

declare type DefenderBonus = {
    type: 'defenderBonus';
    data: null;
};

declare type DestructibleDamaged = {
    type: 'destructibleDamaged';
    data: {
        damage: number;
    };
};

declare type DestructibleDestroyed = {
    type: 'destructibleDestroyed';
    data: null;
};

declare type DestructiblesDefended = {
    type: 'destructiblesDefended';
    data: {
        extra: unknown;
    };
};

declare type Detected = {
    type: 'detected';
    data: VisibleExtra;
};

declare type ElementDefinition = HTMLElement | (() => HTMLElement) | string;

declare type EnemySectorCaptured = {
    type: 'enemySectorCaptured';
    data: null;
};

declare class EventDispatcher<T> {
    private listeners;
    addListener(listener: (event: T) => void): () => boolean;
    dispatch(event: T): void;
    clear(): void;
}

export declare namespace I18n {
    export function t(key: string, lang?: Language): Record<string, any>;
    export function shortShellName(shellType: ShellType, lang?: Language): Record<string, any>;
}

declare type InitMessage = {
    type: 'init';
    states: {
        path: Path;
        value: ValueType;
    }[];
};

export declare function injectStylesheet(): void;

declare type InspireAssist = {
    type: 'inspireAssist';
    data: DamageExtra;
};

export declare type KeyCodes = 'MODIFIER_SHIFT' | 'MODIFIER_CTRL' | 'MODIFIER_ALT' | 'KEY_NOT_FOUND' | 'KEY_NONE' | 'KEY_NULL' | 'KEY_ESCAPE' | 'KEY_1' | 'KEY_2' | 'KEY_3' | 'KEY_4' | 'KEY_5' | 'KEY_6' | 'KEY_7' | 'KEY_8' | 'KEY_9' | 'KEY_0' | 'KEY_MINUS' | 'KEY_EQUALS' | 'KEY_BACKSPACE' | 'KEY_TAB' | 'KEY_Q' | 'KEY_W' | 'KEY_E' | 'KEY_R' | 'KEY_T' | 'KEY_Y' | 'KEY_U' | 'KEY_I' | 'KEY_O' | 'KEY_P' | 'KEY_LBRACKET' | 'KEY_RBRACKET' | 'KEY_RETURN' | 'KEY_LCONTROL' | 'KEY_A' | 'KEY_S' | 'KEY_D' | 'KEY_F' | 'KEY_G' | 'KEY_H' | 'KEY_J' | 'KEY_K' | 'KEY_L' | 'KEY_SEMICOLON' | 'KEY_APOSTROPHE' | 'KEY_GRAVE' | 'KEY_LSHIFT' | 'KEY_BACKSLASH' | 'KEY_Z' | 'KEY_X' | 'KEY_C' | 'KEY_V' | 'KEY_B' | 'KEY_N' | 'KEY_M' | 'KEY_COMMA' | 'KEY_PERIOD' | 'KEY_SLASH' | 'KEY_RSHIFT' | 'KEY_NUMPADSTAR' | 'KEY_LALT' | 'KEY_SPACE' | 'KEY_CAPSLOCK' | 'KEY_F1' | 'KEY_F2' | 'KEY_F3' | 'KEY_F4' | 'KEY_F5' | 'KEY_F6' | 'KEY_F7' | 'KEY_F8' | 'KEY_F9' | 'KEY_F10' | 'KEY_NUMLOCK' | 'KEY_SCROLL' | 'KEY_NUMPAD7' | 'KEY_NUMPAD8' | 'KEY_NUMPAD9' | 'KEY_NUMPADMINUS' | 'KEY_NUMPAD4' | 'KEY_NUMPAD5' | 'KEY_NUMPAD6' | 'KEY_ADD' | 'KEY_NUMPAD1' | 'KEY_NUMPAD2' | 'KEY_NUMPAD3' | 'KEY_NUMPAD0' | 'KEY_NUMPADPERIOD' | 'KEY_OEM_102' | 'KEY_F11' | 'KEY_F12' | 'KEY_F13' | 'KEY_F14' | 'KEY_F15' | 'KEY_KANA' | 'KEY_ABNT_C1' | 'KEY_CONVERT' | 'KEY_NOCONVERT' | 'KEY_YEN' | 'KEY_ABNT_C2' | 'KEY_NUMPADEQUALS' | 'KEY_PREVTRACK' | 'KEY_AT' | 'KEY_COLON' | 'KEY_UNDERLINE' | 'KEY_KANJI' | 'KEY_STOP' | 'KEY_AX' | 'KEY_UNLABELED' | 'KEY_NEXTTRACK' | 'KEY_NUMPADENTER' | 'KEY_RCONTROL' | 'KEY_MUTE' | 'KEY_CALCULATOR' | 'KEY_PLAYPAUSE' | 'KEY_MEDIASTOP' | 'KEY_VOLUMEDOWN' | 'KEY_VOLUMEUP' | 'KEY_WEBHOME' | 'KEY_NUMPADCOMMA' | 'KEY_NUMPADSLASH' | 'KEY_SYSRQ' | 'KEY_RALT' | 'KEY_PAUSE' | 'KEY_HOME' | 'KEY_UPARROW' | 'KEY_PGUP' | 'KEY_LEFTARROW' | 'KEY_RIGHTARROW' | 'KEY_END' | 'KEY_DOWNARROW' | 'KEY_PGDN' | 'KEY_INSERT' | 'KEY_DELETE' | 'KEY_LWIN' | 'KEY_RWIN' | 'KEY_APPS' | 'KEY_POWER' | 'KEY_SLEEP' | 'KEY_WAKE' | 'KEY_WEBSEARCH' | 'KEY_WEBFAVORITES' | 'KEY_WEBREFRESH' | 'KEY_WEBSTOP' | 'KEY_WEBFORWARD' | 'KEY_WEBBACK' | 'KEY_MYCOMPUTER' | 'KEY_MAIL' | 'KEY_MEDIASELECT' | 'KEY_IME_CHAR' | 'KEY_MOUSE0' | 'KEY_LEFTMOUSE' | 'KEY_MOUSE1' | 'KEY_RIGHTMOUSE' | 'KEY_MOUSE2' | 'KEY_MIDDLEMOUSE' | 'KEY_MOUSE3' | 'KEY_MOUSE4' | 'KEY_MOUSE5' | 'KEY_MOUSE6' | 'KEY_MOUSE7' | 'KEY_JOY0' | 'KEY_JOY1' | 'KEY_JOY2' | 'KEY_JOY3' | 'KEY_JOY4' | 'KEY_JOY5' | 'KEY_JOY6' | 'KEY_JOY7' | 'KEY_JOY8' | 'KEY_JOY9' | 'KEY_JOY10' | 'KEY_JOY11' | 'KEY_JOY12' | 'KEY_JOY13' | 'KEY_JOY14' | 'KEY_JOY15' | 'KEY_JOY16' | 'KEY_JOY17' | 'KEY_JOY18' | 'KEY_JOY19' | 'KEY_JOY20' | 'KEY_JOY21' | 'KEY_JOY22' | 'KEY_JOY23' | 'KEY_JOY24' | 'KEY_JOY25' | 'KEY_JOY26' | 'KEY_JOY27' | 'KEY_JOY28' | 'KEY_JOY29' | 'KEY_JOY30' | 'KEY_JOY31' | 'KEY_JOYDUP' | 'KEY_JOYDDOWN' | 'KEY_JOYDLEFT' | 'KEY_JOYDRIGHT' | 'KEY_JOYSTART' | 'KEY_JOYSELECT' | 'KEY_JOYBACK' | 'KEY_JOYALPUSH' | 'KEY_JOYARPUSH' | 'KEY_JOYCROSS' | 'KEY_JOYA' | 'KEY_JOYCIRCLE' | 'KEY_JOYB' | 'KEY_JOYSQUARE' | 'KEY_JOYX' | 'KEY_JOYTRIANGLE' | 'KEY_JOYY' | 'KEY_JOYL1' | 'KEY_JOYBLACK' | 'KEY_JOYR1' | 'KEY_JOYWHITE' | 'KEY_JOYL2' | 'KEY_JOYLTRIGGER' | 'KEY_JOYR2' | 'KEY_JOYRTRIGGER' | 'KEY_JOYAHARD' | 'KEY_JOYBHARD' | 'KEY_JOYXHARD' | 'KEY_JOYYHARD' | 'KEY_JOYBLACKHARD' | 'KEY_JOYWHITEHARD' | 'KEY_JOYLTRIGGERHARD' | 'KEY_JOYRTRIGGERHARD' | 'KEY_JOYALUP' | 'KEY_JOYALDOWN' | 'KEY_JOYALLEFT' | 'KEY_JOYALRIGHT' | 'KEY_JOYARUP' | 'KEY_JOYARDOWN' | 'KEY_JOYARLEFT' | 'KEY_JOYARRIGHT' | 'KEY_DEBUG' | 'KEY_LCDKB_LEFT' | 'KEY_LCDKB_RIGHT' | 'KEY_LCDKB_OK' | 'KEY_LCDKB_CANCEL' | 'KEY_LCDKB_UP' | 'KEY_LCDKB_DOWN' | 'KEY_LCDKB_MENU' | 'AXIS_LX' | 'AXIS_LY' | 'AXIS_RX' | 'AXIS_RY';

declare type Kill = {
    type: 'kill';
    data: {
        vehicle: VehicleWithOwner;
    };
};

declare type Language = 'ru' | 'en';

declare type MultiStun = {
    type: 'multiStun';
    data: {
        stunCount: number;
    };
};

declare type Options = Partial<{
    connect: boolean;
    style: boolean;
    wsHost: string;
    wsPort: number;
}>;

export declare function parseBattleResult(result: unknown): {
    arenaUniqueID: number | null;
    result: "draw" | "win" | "lose";
    common: {
        bonusType: number | null;
        arenaTypeID: number | null;
        arenaId: number;
        winnerTeam: number | null;
        duration: number;
        arenaCreateTime: number;
    };
    players: {
        player: Player | "bot";
        vehicles: WotVehicle[];
        stats: {
            kills: number;
            damageDealt: number;
            damageBlockedByArmor: number;
            damageAssistedTrack: number;
            damageAssistedStun: number;
            damageAssistedSmoke: number;
            damageAssistedRadio: number;
            credits: number;
            capturePoints: number;
            droppedCapturePoints: number;
            damageReceived: number;
            damaged: number;
            directHits: number;
            lifeTime: number;
            mileage: number;
            shots: number;
            spotted: number;
            xp: number;
        };
    }[];
    personal: {
        comp7: {
            ratingDelta: number | null;
            rating: number | null;
            qualActive: boolean | null;
            qualBattleIndex: number | null;
            rank: [number, number] | null;
        };
        details: PersonalDamageDetails[][];
        player: Player | "bot";
        vehicles: WotVehicle[];
        stats: {
            kills: number;
            damageDealt: number;
            damageBlockedByArmor: number;
            damageAssistedTrack: number;
            damageAssistedStun: number;
            damageAssistedSmoke: number;
            damageAssistedRadio: number;
            credits: number;
            capturePoints: number;
            droppedCapturePoints: number;
            damageReceived: number;
            damaged: number;
            directHits: number;
            lifeTime: number;
            mileage: number;
            shots: number;
            spotted: number;
            xp: number;
        };
    } | undefined;
    platoon: ({
        player: Player | "bot";
        vehicles: WotVehicle[];
        stats: {
            kills: number;
            damageDealt: number;
            damageBlockedByArmor: number;
            damageAssistedTrack: number;
            damageAssistedStun: number;
            damageAssistedSmoke: number;
            damageAssistedRadio: number;
            credits: number;
            capturePoints: number;
            droppedCapturePoints: number;
            damageReceived: number;
            damaged: number;
            directHits: number;
            lifeTime: number;
            mileage: number;
            shots: number;
            spotted: number;
            xp: number;
        };
    } | undefined)[];
} | null;

declare type Path = string;

declare type PersonalDamageDetails = {
    crits: CritVariant[];
    damageAssistedInspire: number;
    damageAssistedRadio: number;
    damageAssistedSmoke: number;
    damageAssistedStun: number;
    damageAssistedTrack: number;
    damageBlockedByArmor: number;
    damageDealt: number;
    damageReceived: number;
    deathReason: number;
    directEnemyHits: number;
    directHits: number;
    explosionHits: number;
    fire: number;
    noDamageDirectHitsReceived: number;
    piercingEnemyHits: number;
    piercings: number;
    rickochetsReceived: number;
    spotted: number;
    stunDuration: number;
    stunNum: number;
    targetKills: number;
};

declare type Player = {
    avatar: {
        playerRank?: number;
    };
    bdid: number;
    clanAbbrev: string;
    clanDBID: number;
    name: string;
    prebattleID: number;
    realName: string;
    team: number;
};

declare type PlayerFeedback = Spotted | TargetVisibility | Detected | RadioAssist | TrackAssist | Tanking | Damage | SmokeAssist | InspireAssist | ReceivedDamage | StunAssist | Crit | ReceivedCrit | EnemySectorCaptured | DestructibleDestroyed | DefenderBonus | Kill | BaseCaptureDropped | DestructibleDamaged | DestructiblesDefended | BaseCapturePoints | BaseCaptureBlocked | MultiStun | VehicleHealthAdded;

declare type RadioAssist = {
    type: 'radioAssist';
    data: DamageExtra;
};

declare class ReadonlyWatchableValue<T> {
    private onDispose?;
    private currentValue;
    private readonly subscribers;
    constructor(defaultValue: T, onDispose?: (() => void) | undefined);
    get value(): T;
    protected set value(value: T);
    watch(fn: (value: T) => void, options?: {
        immediate?: boolean;
    }): () => boolean;
    protected trigger(): void;
    protected dispose(): void;
}

declare type ReceivedCrit = {
    type: 'receivedCrit';
    data: CriticalHitExtra;
};

declare type ReceivedDamage = {
    type: 'receivedDamage';
    data: DamageExtra;
};

export declare class RelayDebugConnection extends BaseDebugConnection {
    private states;
    get registeredStates(): ReadonlyWatchableValue<Map<string, any>>;
    constructor(frame: HTMLIFrameElement);
    processCommand(command: string, data: any): void;
    sendState(uuid: string, name: string, value: any): void;
    removeClient(uuid: string): void;
}

export declare class RelayState<T> {
    readonly uuid: UUID;
    private readonly onSet;
    private values;
    private subscribers;
    private selfSubscribers;
    constructor(uuid: UUID, defaultValue: T, onSet: (uuid: UUID, value: T) => void);
    get value(): T;
    set value(value: T);
    valueOf(uuid: UUID): T | undefined;
    get all(): [string, T][];
    get remote(): [string, T][];
    trigger(): void;
    watch(fn: (uuid: UUID, value: (T | undefined)) => void, options?: {
        immediate?: boolean;
        includeSelf?: boolean;
    }): () => void;
    protected change(uuid: UUID, value: T): void;
    protected disconnect(uuid: UUID): void;
}

export declare class RemoteDebugConnection extends BaseDebugConnection {
    private readonly states;
    private readonly bbox;
    constructor(frame: HTMLIFrameElement);
    get registeredStates(): ReadonlyWatchableValue<Map<string, RemoteState>>;
    get boundingBoxes(): ReadonlyWatchableValue<Map<string, {
    width: number;
    height: number;
    x: number;
    y: number;
    }>>;
    dispose(): void;
    setState(state: Record<string, any>): void;
    setValue(key: string, value: any): void;
    processCommand(command: string, data: any): void;
}

declare type RemoteState = {
    type: RemoteStateType;
    value: any;
};

declare type RemoteStateType = 'string' | 'number' | 'boolean' | 'color' | {
    type: 'select';
    variants: string[] | {
        value: string;
        label: string;
    }[];
};

declare type Rotation = [pitch: number, yaw: number, roll: number];

export declare class SdkDebugConnection extends BaseDebugConnection {
    private gameConnectionPrevented;
    constructor(frame: HTMLIFrameElement);
    processCommand(command: string, data: any): void;
    sendMessage(message: InitMessage | ChangeStateMessage | TriggerMessage): void;
    sendInit(initialData: Record<string, any> | undefined): void;
    sendTrigger(path: string, value?: any): void;
    sendChangeState(path: string, value: any): void;
    sendPreventGameConnection(prevent: boolean): void;
}

declare type SDKStatus = 'connecting' | 'connected' | 'disconnected';

export declare function setupStyles(): void;

declare type ShellType = 'HOLLOW_CHARGE' | 'ARMOR_PIERCING' | 'ARMOR_PIERCING_HE' | 'ARMOR_PIERCING_CR' | 'SMOKE' | 'HE_MODERN' | 'HE_LEGACY_STUN' | 'HE_LEGACY_NO_STUN' | 'FLAME';

declare type Skill = {
    tag: string;
    level: number;
};

declare type SmokeAssist = {
    type: 'smokeAssist';
    data: DamageExtra;
};

declare type Spotted = {
    type: 'spotted';
    data: VisibleExtra;
};

export declare type State<T> = {
    value: T | undefined;
    watch: WatchState<T>;
};

declare type StunAssist = {
    type: 'stunAssist';
    data: DamageExtra;
};

declare type Tanking = {
    type: 'tanking';
    data: DamageExtra;
};

declare type Tankman = {
    efficiencyRoleLevel: number;
    vehicleTag: string;
    roles: string[];
    skills: Skill[];
    isFemale: boolean;
};

declare type TargetVisibility = {
    type: 'targetVisibility';
    data: VisibleExtra;
};

declare type TrackAssist = {
    type: 'trackAssist';
    data: DamageExtra;
};

export declare type Trigger<T> = {
    watch: WatchTrigger<T>;
};

declare type TriggerMessage = {
    type: 'trigger';
    path: Path;
    value?: ValueType;
};

declare type UUID = string;

declare type ValueType = any;

declare type Vector3 = [x: number, y: number, z: number];

declare type Vehicle = {
    tag: string;
    localizedName: string;
    localizedShortName: string;
    level: number;
    class: string;
    role: string;
};

declare const VEHICLE_DEVICE_TYPE_NAMES: readonly ["engine", "ammoBay", "fuelTank", "radio", "track", "gun", "turretRotator", "surveyingDevice", "STUN_PLACEHOLDER", "wheel"];

declare const VEHICLE_TANKMAN_TYPE_NAMES: readonly ["commander", "driver", "radioman", "gunner", "loader"];

declare type VehicleHealthAdded = {
    type: 'vehicleHealthAdded';
    data: {
        health: number;
    };
};

declare type VehicleWithOwner = Vehicle & {
    playerName: string;
    playerId: number;
    team: number;
};

declare type VisibleExtra = {
    isVisible: boolean;
    isDirect: boolean;
    isRoleAction: boolean;
    vehicle: VehicleWithOwner;
};

declare type WatchState<T> = (callback: WatchStateCallback<T>, options?: {
    immediate: boolean;
}) => (() => void);

declare type WatchStateCallback<T> = (value: T, old: T) => void;

declare type WatchTrigger<T> = (callback: WatchTriggerCallback<T>) => (() => void);

declare type WatchTriggerCallback<T> = (value: T) => void;

declare class WidgetCommands {
    private readonly onClearDataCallbacks;
    constructor();
    private setup;
    private processEvent;
    onClearData(callback: () => void): {
        setReadyToClearData: (isReady: boolean) => void;
        unsubscribe: () => void;
    };
    forceClearData(): void;
}

export declare namespace WidgetMetaTags {
    export function setAutoHeight(enabled: boolean): void;
    export function setHangarOnly(enabled: boolean): void;
    export function setReadyToClearData(enabled: boolean): void;
    export function setUseSniperMode(enabled: boolean): void;
    export function setPreferredTopLayer(enabled: boolean): void;
    export function setUnlimitedSize(enabled: boolean): void;
    export function setInsets(value: false | string | number | {
        top?: number;
        right?: number;
        bottom?: number;
        left?: number;
    }): void;
    /**
     * @deprecated This function is deprecated. Use setAutoHeight(true) instead.
     */
    export function enableAutoHeight(): void;
    /**
     * @deprecated This function is deprecated. Use setAutoHeight(false) instead.
     */
    export function disableAutoHeight(): void;
}

export declare class WidgetSDK<T extends WidgetsSdkData> {
    private websocket;
    private _status;
    private readonly onStatusChangeCallbacks;
    private readonly onAnyChangeCallbacks;
    private readonly onAnyTriggerCallbacks;
    private readonly dataProxy;
    private readonly debug;
    private port;
    private host;
    get status(): SDKStatus;
    private set status(value);
    get data(): DeepProxy<T>;
    get commands(): WidgetCommands;
    constructor(options?: Options);
    dispose(): void;
    onStatusChange(callback: (status: SDKStatus) => void, options?: {
        immediate: boolean;
    }): () => boolean;
    onAnyChange(callback: (path: string, value: any) => void): () => boolean;
    onAnyTrigger(callback: (path: string, value: any) => void): () => boolean;
    private closeConnection;
    private reconnect;
    private onInitMessage;
    private onClose;
    private onMessage;
}

export declare class WidgetsRelay {
    private readonly uuid;
    private readonly states;
    private readonly lastSendedStates;
    private readonly intervalHandler;
    private ws;
    private readonly relayDebug;
    private throttleInterval;
    get status(): ReadonlyWatchableValue<"connecting" | "connected" | "disconnected">;
    constructor(options?: {
        url?: string;
        uuid?: string;
        reconnect?: boolean;
        channel?: string;
        fullSyncInterval?: number;
        throttleInterval?: number;
    });
    createState<T>(name: string, defaultValue: T): RelayState<T>;
    private sendState;
    dispose(): void;
    private onOpen;
    private onClose;
    private onMessage;
}

export declare class WidgetsRemote {
    private ws;
    private uuid;
    private states;
    private lastState;
    private readonly remoteDebug;
    readonly onAnyChange: EventDispatcher<{
        key: string;
        value: any;
    }>;
    get status(): ReadonlyWatchableValue<"connecting" | "connected" | "disconnected">;
    get fullState(): ReadonlyWatchableValue<Map<string, string | number | boolean>>;
    constructor(options?: {
        url?: string;
        uuid?: string;
        reconnect?: boolean;
        channel?: string;
    });
    private onMessage;
    /**
     * Define a helper element for remote debugging.
     */
    defineElementHelper(key: string, element: ElementDefinition): void;
    /**
     * Defines a remote-controllable state variable that can be synchronized with the remote debug interface.
     *
     * @param {string} key - Unique key for the state variable.
     * @param {Object} [meta] - Optional metadata for the state.
     * @param {RemoteStateType} [meta.type] - Explicit type of the state (overrides type inference).
     * @param {ElementDefinition} [meta.element] - Associated element for UI representation.
     * @param {ElementDefinition} [meta.elementHelper] - Helper element for debugging or visualization.
     */
    defineState<T extends string | number | boolean>(key: string, defaultValue: T, meta?: {
        type?: RemoteStateType;
        element?: ElementDefinition;
        elementHelper?: ElementDefinition;
    }): ReadonlyWatchableValue<T>;
    dispose(): void;
}

export declare interface WidgetsSdkData {
    keyboard: {
        onAnyKey: Trigger<{
            isKeyDown: boolean;
            key: KeyCodes;
        }>;
    } & {
        [key in KeyCodes]: State<boolean>;
    };
    game: {
        language: State<string>;
        region: State<string>;
        version: State<string>;
        server: State<string>;
        state: State<'loading' | 'login' | 'hangar' | 'battle'>;
        serverTime: State<number>;
        fps: State<number>;
        ping: State<number>;
        isInReplay: State<boolean>;
        dataProviderVersion: State<number>;
    };
    player: {
        name: State<string>;
        id: State<number>;
        clanId: State<number>;
        clanTag: State<string>;
    };
    account: {
        credits: State<number>;
        gold: State<number>;
        crystal: State<number>;
        freeXp: State<number>;
        premium: State<{
            basic: {
                active: boolean;
                expiration: number;
            };
            plus: {
                active: boolean;
                expiration: number;
            };
            vip: {
                active: boolean;
                expiration: number;
            };
        }>;
    };
    platoon: {
        isInPlatoon: State<boolean>;
        maxSlots: State<number>;
        commander: State<number>;
        slots: State<({
            name: string;
            clanTag: string;
            dbid: number;
            rating: number;
            timeJoin: number;
            isOffline: boolean;
            vehicle: Vehicle | null;
            isReady: boolean;
        } | null)[]>;
    };
    hangar: {
        isInHangar: State<boolean>;
        battleMode: State<string>;
        isInQueue: State<boolean>;
        onEnqueue: Trigger<null>;
        onDequeue: Trigger<null>;
        vehicle: {
            info: State<Vehicle>;
            xp: State<number>;
            crew: State<Tankman[]>;
            optDevices: State<{
                tag: string | null;
                specialization: string | null;
            }[]>;
            shells: State<{
                tag: string;
                count: number;
            }[]>;
            consumables: State<(string | null)[]>;
            boosters: State<(string | null)[]>;
            isBroken: State<boolean>;
            isInBattle: State<boolean>;
            postProgression: State<{
                level: number;
                features: {
                    optSwitchEnabled: boolean;
                    shellsSwitchEnabled: boolean;
                };
                unlockedModifications: (string | null)[];
                selectedModifications: (string | null)[];
                modifications: string[][];
            }>;
        };
    };
    battle: {
        isInBattle: State<boolean>;
        period: State<{
            tag: string;
            endTime: number;
            length: number;
        }>;
        arenaId: State<number>;
        arena: State<{
            tag: string;
            localizedName: string;
            mode: string;
            gameplay: string;
            team: number;
        }>;
        vehicle: State<Vehicle>;
        health: State<number>;
        maxHealth: State<number>;
        isAlive: State<boolean>;
        position: State<Vector3>;
        rotation: State<Rotation>;
        velocity: State<[linear: number, angular: number]>;
        turretYaw: State<number>;
        turretRotationSpeed: State<number>;
        gunPitch: State<number>;
        aiming: {
            isAutoAim: State<boolean>;
            isServerAim: State<boolean>;
            idealDispersion: State<number>;
            serverDispersion: State<number>;
            clientDispersion: State<number>;
            aimingTime: State<number>;
            aimingMode: State<AimingMode>;
        };
        efficiency: {
            damage: State<number>;
            assist: State<number>;
            blocked: State<number>;
            stun: State<number>;
        };
        teamBases: State<{
            [key: string]: {
                baseID: number;
                points: number;
                timeLeft: number;
                invadersCount: number;
                capturingStopped: boolean;
            }[];
        }>;
        onDamage: Trigger<{
            target: VehicleWithOwner | null;
            attacker: VehicleWithOwner | null;
            damage: number;
            health: number;
            reason: AttackReason;
        }>;
        onPlayerFeedback: Trigger<PlayerFeedback>;
        onBattleResult: Trigger<unknown>;
    };
    dossier: {
        current: State<{
            vehicleTag?: string;
            movingAvgDamage: number;
            damageRating: number;
            battlesCount: number;
        } | null>;
    };
    moeInfo: {
        isAvailable: State<boolean>;
        current: State<{
            vehicleTag: string;
            battleCount: number;
            damageBetterThanNPercent: number[];
        } | null>;
    };
    extensions: WidgetsSdkExtensions;
    registeredExtensions: State<string[]>;
}

declare type WotVehicle = {
    accountDBID: number;
    kills: number;
    damageDealt: number;
    damageBlockedByArmor: number;
    damageAssistedTrack: number;
    damageAssistedStun: number;
    damageAssistedSmoke: number;
    damageAssistedRadio: number;
    spotted: number;
    credits: number;
    capturePoints: number;
    damageReceived: number;
    damaged: number;
    directHits: number;
    lifeTime: number;
    mileage: number;
    shots: number;
    xp: number;
};

export { }