tesla-fleet-api 0.4.0 → 0.6.0

package/dist/bluetooth/vehiclebluetooth.d.cts

@@ -0,0 +1,495 @@
+import { BluetoothVehicleData, VehicleDataEndpoint } from "../const.cjs";
+import { SendOptions, SendRequires, SignedCommandResponse } from "../commands.cjs";
+import { CommandResponse } from "../types/commands.cjs";
+import { WakeUpOptions } from "../types/vehicle.cjs";
+import Vehicle from "../vehicle.cjs";
+import { BluetoothTimeout } from "../exceptions.cjs";
+import { ReplyQueue } from "./async.cjs";
+import { BroadcastListeners, Unsubscribe } from "./broadcast.cjs";
+import { BleCharacteristic, BleDeviceRef, BleTransport } from "./transport.cjs";
+import { BluetoothConfirmation } from "./verify.cjs";
+import { Domain, RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+import { KeyFormFactor, UnsignedMessage, VehicleSleepStatusE, VehicleStatus } from "@teslemetry/tesla-protocol/command/vcsec";
+import { Action } from "@teslemetry/tesla-protocol/command/car_server";
+import { AlertState, ChargeScheduleState, ChargeState, ChildPresenceDetectionState, ClimateState, ClosuresState, CurrentVehicleState, DisplayState, DriveState, GuiSettings, LightShowState, LocationState, MediaDetailState, MediaState, ParentalControlsState, ParkedAccessoryState, PreconditioningScheduleState, SoftwareUpdateState, SohState, SuspensionState, TirePressureState, VehicleConfig, VehicleDetailState, VehicleState } from "@teslemetry/tesla-protocol/command/vehicle";
+import { Role } from "@teslemetry/tesla-protocol/command/keys";
+export interface VehicleBluetoothOptions {
+  transport: BleTransport;
+  /** Raw 32-byte P-256 scalar. `undefined` uses the parent's key. `false` disables signing, for a passive listener. */
+  privateKey?: Buffer | false;
+  /** Skip the scan and connect to this device. */
+  device?: BleDeviceRef;
+  /** How hard a mutating command confirms itself. Defaults to `"ack"`. */
+  confirmation?: BluetoothConfirmation;
+  /**
+   * What to do when nothing resolved a command's outcome. `false`, the default,
+   * reports best-effort success. `true` raises `BluetoothUnconfirmedCommand`.
+   */
+  raise_unconfirmed?: boolean;
+  /**
+   * After this long with no GATT traffic, read a characteristic to hold the
+   * link open. Defaults to 20000. `null` or `0` disables it. The reads delay
+   * an awake car's sleep, so a consumer that wants it to sleep disables them.
+   */
+  keepalive_interval_ms?: number | null;
+  /** Wakes a sleeping vehicle for an infotainment command, instead of raising. Defaults to `true`. */
+  wake_if_asleep?: boolean;
+  /** Connect attempts per connect. Defaults to 3. */
+  max_connect_attempts?: number;
+  /** One connect attempt. Defaults to 20000. */
+  connect_timeout_ms?: number;
+  /** One scan, which must outlast the backend's scan window. Defaults to 10000. */
+  scan_timeout_ms?: number;
+  /**
+   * The reply wait of one infotainment readiness probe. Defaults to 1000, which
+   * a ready car beats by 0.6 s. It starts after the last write, so a slow link
+   * loses none of it to writing, but a link with slow replies needs more.
+   */
+  wake_probe_timeout_ms?: number;
+}
+export interface FindVehicleOptions {
+  /** Match this name exactly, instead of this vehicle's. */
+  name?: string;
+  /** Match this `BleDeviceRef.id`, instead of a name. */
+  address?: string;
+  timeoutMs?: number;
+}
+export interface PairOptions {
+  /** The role the key gets. Defaults to `ROLE_OWNER`. */
+  role?: Role;
+  /** The form factor the vehicle lists the key under. Defaults to `KEY_FORM_FACTOR_CLOUD_KEY`. */
+  form?: KeyFormFactor;
+  /** How long to wait for the key card tap. Defaults to 300000. */
+  timeoutMs?: number;
+  /** Between checks of whether the key was accepted. Defaults to 5000. */
+  pollIntervalMs?: number;
+  /** Stops the wait, for a user who walked away. Nothing is written after it aborts. */
+  signal?: AbortSignal;
+}
+/**
+ * A vehicle reached directly over Bluetooth, with commands signed by AES-GCM.
+ *
+ * All Tesla protocol logic lives here and in `Commands`. A `BleTransport`
+ * supplies raw GATT only, so the same class runs on any backend, Homey's
+ * included. Backends may hang and may misreport their link, so every backend
+ * call is bounded, and a failed or timed-out operation is what counts as a dead
+ * link.
+ *
+ * `Commands.dispatch` holds a VCSEC session's lock across `_send`, and that lock
+ * is not reentrant, so `_send` serializes on its own `domainSendLock` and must
+ * never take `Session.withLock`.
+ *
+ * Sessions survive a reconnect, and the vehicle key they pinned at first contact
+ * survives with them: a new link may re-handshake, but nothing here clears a
+ * session or lets a new link trust a new key.
+ *
+ * A mutating command that times out is unresolved, not failed: in field data 2
+ * of 3 failed writes had executed anyway. So a timed-out command is never sent
+ * again. The outcomes a caller can see:
+ *
+ * - `BluetoothTransportError`: provably never reached the radio. Safe to replay.
+ * - `BluetoothCommandFailed`: state proved it did not apply. Safe to replay.
+ * - `BluetoothUnconfirmedCommand`: it may have run. Never replay it.
+ * - A plain `BluetoothTimeout`: a read, or a step before any write.
+ * - Best-effort success, when `raise_unconfirmed` is off and nothing resolved it.
+ *   `charge_port_door_open` under `"verify"` is the exception, and raises.
+ */
+export default class VehicleBluetooth extends BroadcastListeners {
+  readonly _transport_name: string;
+  protected authMethod: "hmac" | "aes";
+  /** Reply wait with data. */
+  protected defaultTimeoutMs: number;
+  /** Reply wait for a VCSEC actuation. A lost ack is inconclusive, so a shorter wait loses nothing. */
+  protected actuationTimeoutMs: number;
+  /** Wait for data after a bare ack. */
+  protected ackFollowupTimeoutMs: number;
+  /** How long a command woken by `wake_if_asleep` waits for infotainment. */
+  protected wakeTimeoutMs: number;
+  /** How often a wake is resent while infotainment stays silent. */
+  protected wakeResendIntervalMs: number;
+  /** How long an awake car's infotainment may take to finish booting. */
+  protected infotainmentBootTimeoutMs: number;
+  /** How long a charge-port opening has to show in charge state. */
+  protected chargePortVerifyTimeoutMs: number;
+  /** Between charge-state polls. */
+  protected chargePortVerifyIntervalMs: number;
+  /** Bound on one keepalive read. */
+  protected keepaliveTimeoutMs: number;
+  /** The vehicle's BLE name, with the usual `C` suffix. */
+  readonly ble_name: string;
+  readonly confirmation: BluetoothConfirmation;
+  readonly raise_unconfirmed: boolean;
+  wake_if_asleep: boolean;
+  readonly keepalive_interval_ms: number | null;
+  protected readonly transport: BleTransport;
+  protected readonly queues: Partial<Record<Domain, ReplyQueue<RoutableMessage>>>;
+  private readonly maxConnectAttempts;
+  private readonly connectTimeoutMs;
+  private readonly scanTimeoutMs;
+  private readonly wakeProbeTimeoutMs;
+  private readonly domainSendLock;
+  private readonly connectLock;
+  private readonly broadcastWatchers;
+  private device;
+  private link;
+  /** Closing a lost link. A new connect waits for it: a late disconnect could end the new link. */
+  private teardown;
+  private keepaliveTimer;
+  /** When GATT traffic last moved, on the monotonic clock. */
+  private lastActivity;
+  private connected;
+  private readonly connectionListeners;
+  constructor(parent: Vehicle, vin: string, options: VehicleBluetoothOptions);
+  /** Whether `confirmation` is `"optimistic"`. */
+  get optimistic(): boolean;
+  /** Whether `confirmation` is `"verify"`. */
+  get verify_commands(): boolean;
+  /**
+   * Find this vehicle. Never filters by service, because the vehicle advertises
+   * none. A device with free connection slots wins, then the strongest signal.
+   * @throws BluetoothTransportError when the scan fails or finds nothing.
+   */
+  find_vehicle({ name, address, timeoutMs }?: FindVehicleOptions): Promise<BleDeviceRef>;
+  /** Assign the device later connections use. */
+  set_device(device: BleDeviceRef): void;
+  /** The device later connections use, if one has been found or set. */
+  get_device(): BleDeviceRef | undefined;
+  /**
+   * Connect, unless a link is up. Scans first if no device is known. Python
+   * raises there instead, but a Homey app has no scan of its own to run.
+   * @throws BluetoothTransportError when every attempt fails, with the last failure as `cause`.
+   */
+  connect(maxAttempts?: number): Promise<void>;
+  /** Connect if the link is down, as every send does. */
+  connect_if_needed(maxAttempts?: number): Promise<void>;
+  private connectOnce;
+  /** Close a connection, bounded and never throwing: the failure behind it is what gets reported. */
+  private closeConnection;
+  /**
+   * Mark a link lost and start closing it. Only the current link has state to
+   * clear, so a late event from an old link or an abandoned attempt ends there.
+   */
+  private loseLink;
+  /** Tear down the link and wait for it. The next send reconnects. */
+  protected dropLink(reason: string): Promise<void>;
+  /** Drop the link after a failed session setup, unless the failure never touched it. */
+  protected dropLinkOnFailure(reason: string, error: unknown): Promise<void>;
+  /**
+   * Disconnect, waiting out any connect in progress.
+   * @returns Whether there was a connection.
+   */
+  disconnect(): Promise<boolean>;
+  /**
+   * Listen for the link coming up and going down. `true` fires once
+   * notifications are live, and `false` once the link is lost, for any reason
+   * and however it was noticed. Only real changes fire. A backend that drops
+   * silently makes `false` as late as the next operation to time out.
+   */
+  listen_connection_status(callback: (connected: boolean) => void): Unsubscribe;
+  private setConnected;
+  private startKeepalive;
+  private stopKeepalive;
+  private scheduleKeepalive;
+  /** Idle-triggered, so an active link pays nothing. It never raises, never reconnects and never wakes the car. */
+  private keepaliveTick;
+  /**
+   * One bounded read, with every failure swallowed. A read that times out
+   * still marks the link lost, as any read does here: on a backend that
+   * misreports its link, that is how a dead idle link is found before the next
+   * command writes to it. Python only drops the read.
+   */
+  private keepaliveRead;
+  /** A backend calls this, so it must never throw. */
+  private onNotify;
+  /** Route one whole message: replies to their domain's queue, the rest to whoever listens. */
+  private onMessage;
+  /** Write one frame, with its chunks together, each bounded. */
+  private writeFrame;
+  /**
+   * Read a characteristic, bounded. A rejected or timed-out read marks the link
+   * lost, whatever `isConnected` says, as that is how a dead link is found on a
+   * backend that misreports it. The exception is `BleNotSubmittedError` with the
+   * link reported up: no radio I/O happened, and a stack that hides Generic
+   * Access rejects those reads that way on a healthy link.
+   * @throws BluetoothTransportError when there is no link.
+   */
+  protected gattRead(characteristic: BleCharacteristic, timeoutMs?: number): Promise<Uint8Array>;
+  protected _send(msg: RoutableMessage, requires: SendRequires, options?: SendOptions): Promise<RoutableMessage>;
+  /**
+   * Watch for broadcasts showing the requested state. A lost ack does not stop
+   * the car broadcasting the change it caused. Only a status after the write
+   * counts, as one from before it says nothing.
+   */
+  private armBroadcastWatcher;
+  /**
+   * Race the addressed reply against a matching broadcast. A mismatch does not
+   * fail fast, because it may predate the actuation and a later broadcast can
+   * still confirm it. Only a mismatch still standing when the whole window has
+   * run out proves the command did not apply, and a lost link cuts the window
+   * short, so it proves nothing then.
+   */
+  private awaitReplyOrBroadcast;
+  /**
+   * Wait for the reply carrying `requires`, or a bare ack of this request.
+   * @param signal Ends the wait early, as a timeout does.
+   */
+  private awaitReply;
+  /**
+   * Whether a reply must be ignored rather than acted on. The link is shared, so
+   * an addressed reply can be a late answer to an earlier request, and acting on
+   * one can resend a command or report one that never ran.
+   *
+   * A reply naming another request is never ours. One naming no request must
+   * still be heard, because real VCSEC leaves `request_uuid` empty, but nothing
+   * ties it to this request unless its session-info tag or its encryption does,
+   * and both of those are checked later. So it may ack a command or answer a
+   * read, and it may not make anything happen: not a resend or a fault, and a
+   * status does not stand in for an actuation's ack.
+   */
+  private isForeignReply;
+  /** A session that a reply left unready cannot sign, and that reply proved nothing. */
+  protected ensureHandshake(domain: Domain): Promise<void>;
+  /** A failed handshake drops the link, so a retry starts on a fresh one. */
+  handshakeVehicleSecurity(): Promise<void>;
+  /**
+   * A failed handshake drops the link, unless VCSEC reports the car asleep:
+   * its infotainment is meant to be silent then, and that read proves the link.
+   */
+  handshakeInfotainment(): Promise<void>;
+  /**
+   * Sign and write a mutating command, with no reply wait. A write that fails
+   * provably before submission still raises. One that entered the backend may
+   * have reached the car, so even here it must not let a router replay it, and
+   * it follows `raise_unconfirmed`.
+   */
+  private sendOptimistic;
+  /** End a ladder that could not determine what happened. */
+  private unconfirmedOutcome;
+  /**
+   * Confirm a timed-out command by state, when `"verify"` asks for it.
+   * @returns Success, or `null` if the state could not be read. An unreadable car is never woken to verify.
+   * @throws BluetoothCommandFailed when the state shows it did not apply, whatever `raise_unconfirmed` says.
+   */
+  private verifyTimeout;
+  /**
+   * Open the flap or release a cable. Under `"verify"`, the charging subsystem
+   * is made ready first, and only physical state counts as success afterwards:
+   * an opening has been reported waking a sleeping car without releasing the
+   * latch. No readiness failure has sent anything, so a router may fail over on
+   * any of them. Once the one opening write has gone, an unresolved result always
+   * raises `BluetoothUnconfirmedCommand`, whatever `raise_unconfirmed` says, and
+   * it is never sent again: a best-effort success would hide a latch that never
+   * released, and a replay could release a cable the caller had plugged back in.
+   * Other modes keep the ordinary VCSEC ladder.
+   * @throws BluetoothCommandFailed when the car is asleep with `wake_if_asleep` off, or the cable state is unknown.
+   * @throws BluetoothTimeout when the car is not ready in time.
+   * @throws BluetoothUnconfirmedCommand when physical state never showed the opening.
+   */
+  charge_port_door_open(): Promise<CommandResponse>;
+  /**
+   * Everything before the opening, under one `wakeTimeoutMs` deadline.
+   * @returns Whether a cable is connected, which picks the proof of success.
+   */
+  private chargePortPreflight;
+  private chargePortReadiness;
+  /**
+   * Poll for the physical result, holding to the goal set before the opening:
+   * an open flap must never stand in for a latch that did not release. Nothing
+   * here may send the opening again, and no failed read may reach a router as
+   * anything but unconfirmed.
+   */
+  private verifyChargePortOpened;
+  /**
+   * Send a VCSEC actuation through the confirmation ladder. A plan's check also
+   * races the ack, so `options` is ignored: the plan is the only source of it.
+   */
+  protected sendVehicleSecurity(command: UnsignedMessage, _options?: Pick<SendOptions, "confirmBroadcast">): Promise<CommandResponse>;
+  /**
+   * Send an infotainment command through the confirmation ladder. `mutating:
+   * false` is exempt: `ping` always waits for its real reply.
+   */
+  protected sendInfotainment(action: Action, { mutating }?: {
+    mutating?: boolean;
+  }): Promise<SignedCommandResponse>;
+  private infotainmentLadder;
+  /**
+   * Wake a sleeping car until infotainment can take a command.
+   * @throws BluetoothCommandFailed when it cannot: the command provably never ran.
+   */
+  protected wakeForCommand(timeout: BluetoothTimeout): Promise<void>;
+  /** VCSEC's sleep status, or `null` if unreadable. */
+  protected sleepStatus(): Promise<VehicleSleepStatusE | null>;
+  /** Whether VCSEC reports the car asleep; `false` if unreadable. */
+  protected vehicleAsleep(): Promise<boolean>;
+  /** The vehicle security computer's `VehicleStatus`. It answers while the car sleeps. */
+  vehicle_state(): Promise<VehicleStatus>;
+  private readVehicleData;
+  /** The charging state. */
+  charge_state(): Promise<ChargeState>;
+  /** The HVAC and cabin climate state. */
+  climate_state(): Promise<ClimateState>;
+  /** The driving state, including speed and power. */
+  drive_state(): Promise<DriveState>;
+  /** The vehicle's location. */
+  location_state(): Promise<LocationState>;
+  /** The doors, windows, trunks and locks, as infotainment reports them. */
+  closures_state(): Promise<ClosuresState>;
+  /** The charge schedules. */
+  charge_schedule_state(): Promise<ChargeScheduleState>;
+  /** The preconditioning schedules. */
+  preconditioning_schedule_state(): Promise<PreconditioningScheduleState>;
+  /** The tire pressures. */
+  tire_pressure_state(): Promise<TirePressureState>;
+  /** The media playback state. */
+  media_state(): Promise<MediaState>;
+  /** Detail on the media playing now. */
+  media_detail_state(): Promise<MediaDetailState>;
+  /** The software update state. */
+  software_update_state(): Promise<SoftwareUpdateState>;
+  /** The parental controls state. */
+  parental_controls_state(): Promise<ParentalControlsState>;
+  /** The display units and formats. */
+  gui_settings(): Promise<GuiSettings>;
+  /** The state of parked accessories, such as a tent. */
+  parked_accessory_state(): Promise<ParkedAccessoryState>;
+  /**
+   * The older infotainment vehicle state, tag 6, for older firmware. Not `current_vehicle_state`, nor VCSEC's `vehicle_state`.
+   */
+  legacy_vehicle_state(): Promise<VehicleState>;
+  /**
+   * The infotainment vehicle state, tag 18, on current firmware. Not `legacy_vehicle_state`, nor VCSEC's `vehicle_state`.
+   */
+  current_vehicle_state(): Promise<CurrentVehicleState>;
+  /** The vehicle's fixed configuration. */
+  vehicle_config(): Promise<VehicleConfig>;
+  /** The battery state of health. */
+  soh_state(): Promise<SohState>;
+  /** The vehicle's name and software details. */
+  vehicle_detail_state(): Promise<VehicleDetailState>;
+  /** The display state. */
+  display_state(): Promise<DisplayState>;
+  /** The active alerts. */
+  alert_state(): Promise<AlertState>;
+  /** The light show state. */
+  light_show_state(): Promise<LightShowState>;
+  /** The suspension state. */
+  suspension_state(): Promise<SuspensionState>;
+  /** The child presence detection state. */
+  child_presence_detection_state(): Promise<ChildPresenceDetectionState>;
+  /**
+   * Several sub-states in one signed read. This is not the cloud method: it
+   * takes `BluetoothVehicleData` values, not `VehicleDataEndpoint`, and resolves
+   * to `VehicleData`, not a REST envelope. There is no default of every endpoint,
+   * because as few as two together have exceeded the response size limit, which
+   * raises `TeslaFleetMessageFaultResponseSizeExceedsMTU`. Prefer one reader each.
+   * @param endpoints An explicit list. `[]` asks for nothing.
+   * @throws BluetoothCloudUnavailableError for anything else, sending nothing: no argument and REST endpoint names are the cloud call, which a router can fail over to.
+   */
+  vehicle_data(endpoints?: BluetoothVehicleData[] | VehicleDataEndpoint[] | string): Promise<any>;
+  /**
+   * The name set in the vehicle, read from GATT Device Name. It is not advertised.
+   * The vehicle prefixes it with a key emoji once it is available.
+   * @returns The name, or `null` if it never appeared: a backend may hide Generic Access.
+   */
+  query_display_name(max_attempts?: number): Promise<string | null>;
+  /** GATT Appearance, or `null` if it cannot be read. */
+  query_appearance(): Promise<Uint8Array | null>;
+  /** The version characteristic as a big-endian integer, or `null` if it cannot be read. */
+  query_version(): Promise<number | null>;
+  private moveClosure;
+  /** Opens the front driver door. */
+  open_front_driver_door(): Promise<CommandResponse>;
+  /** Closes the front driver door. Doors have no reliable powered close on a Model 3. */
+  close_front_driver_door(): Promise<CommandResponse>;
+  /** Opens the front passenger door. */
+  open_front_passenger_door(): Promise<CommandResponse>;
+  /** Closes the front passenger door. Doors have no reliable powered close on a Model 3. */
+  close_front_passenger_door(): Promise<CommandResponse>;
+  /** Opens the rear driver door. */
+  open_rear_driver_door(): Promise<CommandResponse>;
+  /** Closes the rear driver door. Doors have no reliable powered close on a Model 3. */
+  close_rear_driver_door(): Promise<CommandResponse>;
+  /** Opens the rear passenger door. */
+  open_rear_passenger_door(): Promise<CommandResponse>;
+  /** Closes the rear passenger door. Doors have no reliable powered close on a Model 3. */
+  close_rear_passenger_door(): Promise<CommandResponse>;
+  /** Opens the rear trunk. */
+  open_rear_trunk(): Promise<CommandResponse>;
+  /** Closes the rear trunk. */
+  close_rear_trunk(): Promise<CommandResponse>;
+  /**
+   * Ask the vehicle to add this instance's key, which someone confirms by tapping
+   * a key card on the console. Resolves once the key is on the whitelist.
+   *
+   * The whitelist operation is written exactly once, because a resend prompts
+   * the user again. Its reply is one frame, which a link that cycles during the
+   * walk to the car can lose, so completion is also proved by polling: a VCSEC
+   * handshake only succeeds once this key is whitelisted, and it reconnects, so
+   * the wait survives a dropped link.
+   *
+   * Success needs positive evidence: an explicit success reply, or an
+   * authenticated handshake with this key. Python takes any reply without a
+   * whitelist fault, which a WAIT or a bare ack satisfies before the tap.
+   *
+   * Tesla's Go SDK sends a bare `ToVCSECMessage` here. This wraps the
+   * `UnsignedMessage` in a `RoutableMessage`, as Python does, and that has paired
+   * a real car. If pairing fails on another vehicle, look there first.
+   * @throws RangeError when `pollIntervalMs` is not positive, before anything is sent.
+   * @throws SigningDisabled when this instance has no key, before anything is sent.
+   * @throws BluetoothTimeout when nothing confirmed it by `timeoutMs`, with the link dropped.
+   * @throws WhitelistOperationStatus or a subclass when the vehicle refused the key.
+   * @throws The reason of `signal`, once it aborts. The link is kept.
+   */
+  pair({ role, form, timeoutMs, pollIntervalMs, signal }?: PairOptions): Promise<void>;
+  private confirmPairing;
+  /**
+   * Whether this key is on the whitelist: a VCSEC handshake only completes once
+   * it is. Any failure means "not yet", so polling carries on across a dropped
+   * link. It sends one request, unlike `handshake`, because the next poll is the
+   * retry, and nothing may be written after a `pair` is aborted.
+   */
+  private pairProbe;
+  /**
+   * Look for a whitelist reply that arrived after `_send` stopped waiting. This
+   * must run before a probe, whose `_send` discards what is queued. Anything else
+   * in the queue stays there.
+   * @returns Whether one was there and explicitly reported success.
+   * @throws WhitelistOperationStatus or a subclass when it reported a refusal.
+   */
+  private consumeLateWhitelistReply;
+  /**
+   * Whether a reply to the whitelist operation says the key was added. Only an
+   * OK with a whitelist status and no failure does. A WAIT means the car is
+   * still waiting for the tap, and a bare ack, a status or anything else says
+   * nothing, so `pair` goes on polling.
+   * @throws WhitelistOperationStatus or a subclass when the reply is a refusal.
+   */
+  private whitelistReplyConfirms;
+  /**
+   * Wake the vehicle. Takes `VehicleSpecific`'s options, but resolves to a
+   * `CommandResponse`, not the REST `VehicleResponse`.
+   *
+   * Without `wait`, this sends the RKE wake to the vehicle security computer,
+   * which acks well before infotainment can answer, so an infotainment command
+   * sent straight after can still time out.
+   *
+   * With `wait`, it blocks until infotainment completes a fresh handshake, the
+   * only proof it can take commands: VCSEC reports awake seconds before that.
+   * The wake is idempotent, so it is resent every 3 s until then.
+   * @param options.timeoutMs Deadline for `wait`, in milliseconds. Defaults to 30000.
+   * @throws BluetoothTimeout at the deadline, with the link dropped.
+   */
+  wake_up({ wait, timeoutMs }?: WakeUpOptions): Promise<any>;
+  /**
+   * Probe infotainment until it answers. With `wake`, the RKE wake is sent
+   * first and resent every `wakeResendIntervalMs`.
+   * @param over Stops the probing, for a caller that has stopped waiting.
+   * @throws BluetoothTimeout at the deadline.
+   */
+  protected awaitInfotainment(timeoutMs: number, wake: boolean, over?: AbortSignal): Promise<void>;
+  /**
+   * Handshake with infotainment, always with a fresh request: only a live reply
+   * proves it is awake, so a cached session counts for nothing.
+   */
+  private probeInfotainment;
+}