tesla-fleet-api 0.3.0 → 0.4.0

package/dist/exceptions.cjs

@@ -0,0 +1,1487 @@
+// src/exceptions.ts
+/**
+* Base class for all Tesla exceptions.
+*/
+var TeslaFleetError = class extends Error {
+	static message = "An unknown error has occurred.";
+	static status = null;
+	static key = null;
+	static code = null;
+	data;
+	status;
+	key;
+	code;
+	constructor(data = null, status = null, options) {
+		const cls = new.target;
+		super(cls.message, options);
+		this.name = cls.name;
+		this.data = data;
+		this.status = status || cls.status;
+		this.key = cls.key;
+		this.code = cls.code;
+	}
+};
+/**
+* A request to the API could not be completed: `fetch` rejected (DNS,
+* refused connection, TLS, reset) or the request timed out. The underlying
+* error is kept as `cause`.
+*/
+var TeslaFleetConnectionError = class extends TeslaFleetError {
+	static message = "Could not connect to the API.";
+};
+/**
+* A cloud REST call was made on a vehicle that is only reachable over Bluetooth.
+*/
+var BluetoothCloudUnavailableError = class extends TeslaFleetError {
+	static message = "This vehicle is only reachable over Bluetooth; the cloud API is unavailable.";
+};
+/**
+* Bluetooth command timed out waiting for vehicle response.
+*/
+var BluetoothTimeout = class extends TeslaFleetError {
+	static message = "Bluetooth command timed out waiting for vehicle response.";
+};
+/**
+* A mutating Bluetooth command has an unresolved outcome.
+*
+* The write either completed and its ack was lost, or it entered backend I/O
+* and then failed/timed out in a way that cannot prove whether the vehicle
+* received it. It can also have acknowledged the request without a required
+* physical state check confirming completion. The vehicle may have executed
+* the command - lock/unlock have both been observed to execute despite this
+* error. Treat the outcome as unknown, not failed: verify by reading state
+* back when possible, and never blind-retry or re-issue the same command on
+* another transport, since it may already have run.
+*
+* Extends `BluetoothTimeout` so existing `instanceof BluetoothTimeout`
+* handling still catches it, while remaining distinguishable from it (and
+* from `BluetoothTransportError`, the provable pre-submission transport
+* failure) via `unconfirmed` - e.g. a BLE-primary/cloud-fallback router should
+* not fail over on this error, since failing over risks double-executing the
+* command.
+*/
+var BluetoothUnconfirmedCommand = class extends BluetoothTimeout {
+	static message = "Bluetooth command outcome could not be confirmed after submission; it may have executed anyway.";
+	unconfirmed = true;
+};
+/**
+* A mutating Bluetooth command was proven NOT to have taken effect.
+*
+* Unlike `BluetoothUnconfirmedCommand` (ack lost, outcome unknown), this
+* means a state check - a `confirmation="verify"` post-timeout read, or
+* the vehicle's own status broadcast still showing a different value once
+* the whole confirmation window elapsed - actively contradicted the
+* requested end state. That makes it safe to fail over: a router replaying the
+* command on a fallback transport is not at risk of double-executing an
+* already-applied command, because this one demonstrably did not apply.
+* Deliberately does NOT subclass `BluetoothTimeout`/
+* `BluetoothUnconfirmedCommand` so a fallback router's per-command
+* failover (which only special-cases the ambiguous case) treats it like any
+* other ordinary failure and tries the next backend.
+*/
+var BluetoothCommandFailed = class extends TeslaFleetError {
+	static message = "Bluetooth command was proven not to have taken effect.";
+};
+/**
+* The Bluetooth transport failed provably before the write reached the vehicle.
+*
+* Covers connect, notify-subscribe, and GATT characteristic-resolution
+* failures - all raised by the local BLE stack before any bytes go out over
+* the air, so a fallback router can safely retry the same command
+* elsewhere. A GATT write that entered backend I/O and then failed or timed
+* out is delivery-ambiguous instead (the write may have reached the
+* vehicle) and raises `BluetoothTimeout`/`BluetoothUnconfirmedCommand`,
+* not this class - see those exceptions.
+*/
+var BluetoothTransportError = class extends TeslaFleetError {
+	static message = "The Bluetooth transport failed before a vehicle response could be awaited.";
+};
+/**
+* The response from the server was not JSON.
+*/
+var ResponseError = class extends TeslaFleetError {
+	static message = "The response from the server was not JSON.";
+};
+/**
+* The data request or command is unknown.
+*/
+var InvalidCommand = class extends TeslaFleetError {
+	static message = "The data request or command is unknown.";
+	static status = 400;
+	static key = "invalid_command";
+};
+/**
+* A field in the input is not valid.
+*/
+var InvalidField = class extends TeslaFleetError {
+	static message = "A field in the input is not valid.";
+	static status = 400;
+	static key = "invalid_field";
+};
+/**
+* The request body is not valid, a description giving a more specific error message may be returned.
+*/
+var InvalidRequest = class extends TeslaFleetError {
+	static message = "The request body is not valid";
+	static status = 400;
+	static key = "invalid_request";
+};
+/**
+* The "code" in request body is invalid, generate a new one and try again.
+*/
+var InvalidAuthCode = class extends TeslaFleetError {
+	static message = "The 'code' in request body is invalid, generate a new one and try again.";
+	static status = 400;
+	static key = "invalid_auth_code";
+};
+/**
+* Invalid redirect URI/URL. The authorize redirect URI and token redirect URI must match.
+*/
+var InvalidRedirectUrl = class extends TeslaFleetError {
+	static message = "Invalid redirect URI/URL. The authorize redirect URI and token redirect URI must match.";
+	static status = 400;
+	static key = "invalid_redirect_url";
+};
+/**
+* We don't recognize this client_id and client_secret combination. Use the client_id and client_secret that has been granted for the application.
+*/
+var UnauthorizedClient = class extends TeslaFleetError {
+	static message = "We don't recognize this client_id and client_secret combination. Use the client_id and client_secret that has been granted for the application.";
+	static status = 400;
+	static key = "unauthorized_client";
+};
+/**
+* The vehicle has turned off remote access.
+*/
+var MobileAccessDisabled = class extends TeslaFleetError {
+	static message = "The vehicle has turned off remote access.";
+	static status = 401;
+	static key = "mobile_access_disabled";
+};
+/**
+* Third party specific error when no access token is provided.
+*/
+var MissingToken = class extends TeslaFleetError {
+	static message = "Missing access token.";
+	static status = 401;
+};
+/**
+* Teslemetry specific error when no access token is provided.
+*/
+var MissingTeslemetryToken = class extends MissingToken {
+	static key = "missing_token";
+};
+/**
+* Tessie specific error when no access token is provided.
+*/
+var MissingTessieToken = class extends MissingToken {
+	static key = "Access token is required";
+};
+/**
+* Third party specific error for invalid access token.
+*/
+var InvalidToken = class extends TeslaFleetError {
+	static message = "Invalid access token.";
+	static status = 401;
+};
+/**
+* Teslemetry specific error for invalid access token.
+*/
+var InvalidTeslemetryToken = class extends InvalidToken {
+	static key = "invalid_token";
+};
+/**
+* Tessie specific error for invalid access token.
+*/
+var InvalidTessieToken = class extends InvalidToken {
+	static key = "Invalid access token";
+};
+/**
+* The OAuth token is invalid.
+*/
+var OAuthInvalid = class extends TeslaFleetError {
+	static message = "The OAuth token is invalid.";
+	static status = 401;
+	static key = "invalid bearer token";
+};
+/**
+* The OAuth token has expired.
+*/
+var OAuthExpired = class extends TeslaFleetError {
+	static message = "The OAuth token has expired.";
+	static status = 401;
+	static key = "token expired (401)";
+};
+/**
+* Teslemetry OAuth dynamic client registration (RFC 7591) failed.
+*
+* Covers a transport/timeout failure reaching the registration endpoint, a
+* non-2xx response, a response body that isn't valid JSON, and a
+* well-formed response missing a usable `client_id`. The specific reason
+* is carried in `data`.
+*/
+var TeslemetryRegistrationError = class extends TeslaFleetError {
+	static message = "Teslemetry dynamic client registration failed.";
+};
+/**
+* The user has reset their password and a new auth code is required, or the refresh_token has already been used.
+*/
+var LoginRequired = class extends TeslaFleetError {
+	static message = "The user has reset their password and a new auth code is required, or the refresh_token has already been used.";
+	static status = 401;
+	static key = "login_required";
+};
+/**
+* Payment is required in order to use the API (non-free account only).
+*/
+var PaymentRequired = class extends TeslaFleetError {
+	static message = "Payment is required in order to use the API (non-free account only).";
+	static status = 402;
+};
+/**
+* Subscription is required in order to use Teslemetry.
+*/
+var SubscriptionRequired = class extends TeslaFleetError {
+	static message = "Subscription is required in order to use Teslemetry.";
+	static status = 402;
+	static key = "subscription_required";
+};
+/**
+* Subscription is required in order to use Teslemetry.
+*/
+var VehicleSubscriptionRequired = class extends TeslaFleetError {
+	static message = "Vehicle data subscription is required to make this request.";
+	static status = 402;
+	static key = "vehicle_subscription_required";
+};
+/**
+* Account has insufficient credits to make this request.
+*/
+var InsufficientCredits = class extends TeslaFleetError {
+	static message = "Account has insufficient command credits to make this request.";
+	static status = 402;
+	static key = "insufficient_credits";
+};
+/**
+* Access to this resource is not authorized, developers should check required Scope.
+*/
+var Forbidden = class extends TeslaFleetError {
+	static message = "Access to this resource is not authorized, developers should check required Scope.";
+	static status = 403;
+	static key = "Unauthorized missing scopes";
+};
+/**
+* The requested scopes are not granted.
+*/
+var InvalidScope = class extends TeslaFleetError {
+	static message = "The requested scopes are not granted.";
+	static status = 403;
+	static key = "invalid_scope";
+};
+/**
+* The vehicle is unsupported.
+*/
+var UnsupportedVehicle = class extends TeslaFleetError {
+	static message = "The vehicle is unsupported.";
+	static status = 403;
+	static key = "unsupported vehicle";
+};
+/**
+* The requested resource does not exist.
+*/
+var NotFound = class extends TeslaFleetError {
+	static message = "The requested resource does not exist.";
+	static status = 404;
+};
+/**
+* The HTTP method is not allowed.
+*/
+var InvalidMethod = class extends TeslaFleetError {
+	static message = "The HTTP method is not allowed.";
+	static status = 405;
+	static key = "invalid_method";
+};
+/**
+* The operation is not allowed.
+*/
+var NotAllowed = class extends TeslaFleetError {
+	static message = "The operation is not allowed.";
+	static status = 405;
+};
+/**
+* The HTTP request does not have a Content-Type header set to application/json.
+*/
+var NotAcceptable = class extends TeslaFleetError {
+	static message = "The HTTP request does not have a Content-Type header set to application/json.";
+	static status = 406;
+};
+/**
+* The vehicle is not "online.
+*/
+var VehicleOffline = class extends TeslaFleetError {
+	static message = "The vehicle is not 'online'.";
+	static status = 408;
+};
+/**
+* A condition has not been met to process the request.
+*/
+var PreconditionFailed = class extends TeslaFleetError {
+	static message = "A condition has not been met to process the request.";
+	static status = 412;
+};
+/**
+* This user is not present in the current region.
+*/
+var InvalidRegion = class extends TeslaFleetError {
+	static message = "This user is not present in the current region.";
+	static status = 421;
+};
+/**
+* There is a semantic problem with the data, e.g. missing or invalid data.
+*/
+var InvalidResource = class extends TeslaFleetError {
+	static message = "There is a semantic problem with the data, e.g. missing or invalid data.";
+	static status = 422;
+};
+/**
+* Account is locked, and must be unlocked by Tesla.
+*/
+var Locked = class extends TeslaFleetError {
+	static message = "Account is locked, and must be unlocked by Tesla.";
+	static status = 423;
+};
+/**
+* The response from Tesla was invalid.
+*/
+var InvalidResponse = class extends TeslaFleetError {
+	static message = "The response from Tesla was invalid.";
+	static status = 424;
+};
+/**
+* Account or server is rate limited.
+*/
+var RateLimited = class extends TeslaFleetError {
+	static message = "Account or server is rate limited.";
+	static status = 429;
+};
+/**
+* Querying for a user/vehicle without proper privacy settings.
+*/
+var ResourceUnavailableForLegalReasons = class extends TeslaFleetError {
+	static message = "Querying for a user/vehicle without proper privacy settings.";
+	static status = 451;
+};
+/**
+* Client has closed the request before the server could send a response.
+*/
+var ClientClosedRequest = class extends TeslaFleetError {
+	static message = "Client has closed the request before the server could send a response.";
+	static status = 499;
+};
+/**
+* An error occurred while processing the request.
+*/
+var InternalServerError = class extends TeslaFleetError {
+	static message = "An error occurred while processing the request.";
+	static status = 500;
+};
+/**
+* The server, acting as a gateway, received an invalid response from an upstream server.
+*/
+var BadGateway = class extends TeslaFleetError {
+	static message = "The server, acting as a gateway, received an invalid response from an upstream server.";
+	static status = 502;
+};
+/**
+* The energy gateway is unreachable.
+*/
+var EnergyGatewayUnreachable = class extends BadGateway {
+	static message = "The energy gateway is unreachable.";
+	static key = "energy_gateway_unreachable";
+};
+/**
+* Either an internal service or a vehicle did not respond (timeout).
+*/
+var ServiceUnavailable = class extends TeslaFleetError {
+	static message = "Either an internal service or a vehicle did not respond (timeout).";
+	static status = 503;
+};
+/**
+* Server did not receive a response.
+*/
+var GatewayTimeout = class extends TeslaFleetError {
+	static message = "Server did not receive a response.";
+	static status = 504;
+};
+/**
+* Vehicle responded with an error - might need a reboot, OTA update, or service.
+*/
+var DeviceUnexpectedResponse = class extends TeslaFleetError {
+	static message = "Vehicle responded with an error - might need a reboot, OTA update, or service.";
+	static status = 540;
+};
+/**
+* Errors related to this library.
+*/
+var LibraryError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+/**
+* A signed operation was attempted on a vehicle constructed with signing
+* explicitly disabled.
+*/
+var SigningDisabled = class extends LibraryError {
+	constructor() {
+		super("This vehicle was constructed with command signing explicitly disabled. Any signed command or read needs a real private key.");
+	}
+};
+/**
+* An existing private key file could not be loaded as a usable key.
+*
+* `reason` is one of `"unreadable"` (I/O failure), `"malformed"` (not valid
+* PEM), `"encrypted"` (PEM requires a passphrase), or `"wrong_type"` (loaded
+* key is not the expected type). A local key-file failure, not an upstream
+* Fleet API error, so this extends `LibraryError` rather than
+* `TeslaFleetError`.
+*/
+var PrivateKeyError = class extends LibraryError {
+	reason;
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+	}
+};
+/**
+* The requested action requires a signed command; the unsigned cloud API cannot actuate it.
+*
+* Energy gateways have been observed acknowledging this class of unsigned
+* `grpc_command` without physically operating the grid contactor - see
+* `EnergySite.set_island_mode`. Pair an RSA key with
+* `EnergySite.add_authorized_client`, then either build the energy site
+* with that `private_key` and its `din` to sign it through the cloud, or
+* issue it through a signed local LAN backend (composed via
+* `EnergySiteRouter`).
+*/
+var SignedCommandRequired = class extends TeslaFleetError {
+	static message = "This command cannot actuate via the unsigned cloud API - gateways acknowledge it without operating the contactor. Pair a key with add_authorized_client, then create the energy site with that private_key and its din, or use a signed local control path (EnergySiteRouter).";
+};
+/**
+* An energy gateway's presence-proof window expired before verification.
+*
+* The gateway itself reported the terminal `PENDING_VERIFICATION_TIMEOUT`
+* state (`AuthorizedClientState`) - the ~9-minute window to confirm the
+* key (typically via a physical breaker/switch toggle) closed with no
+* confirmation. The registration is dead; re-register the *same* public
+* key with `add_authorized_client` to reset the window and retry, rather
+* than generating a new key.
+*/
+var AuthorizedClientPairingTimedOut = class extends TeslaFleetError {
+	static message = "Authorized-client pairing timed out: the presence-proof window expired (PENDING_VERIFICATION_TIMEOUT). Re-register the same public key to reset the window and retry.";
+};
+/**
+* `wait_until_paired()`'s own bounded overall wait elapsed.
+*
+* Distinct from `AuthorizedClientPairingTimedOut`: the gateway had not
+* reported a terminal state (the registration may still be alive, e.g.
+* still `PENDING_VERIFICATION`, or the local `verify_by_use` check
+* kept failing) when the caller's `timeout` ran out. Retry by calling
+* `wait_until_paired()` again.
+*/
+var AuthorizedClientWaitExpired = class extends TeslaFleetError {
+	static message = "Timed out waiting for authorized-client pairing to complete.";
+};
+/**
+* A `session_info` reply failed local authentication and was discarded.
+*
+* Raised when the reply's `session_info_tag` HMAC does not verify, is
+* absent, the echoed `request_uuid` does not match the outstanding
+* request it claims to answer, or its clock time regresses within the same
+* epoch. Also raised when the reply carries an empty `publicKey` (so no
+* shared key can be derived to verify a tag) with a status other than
+* `SESSION_INFO_STATUS_KEY_NOT_ON_WHITELIST`, which raises
+* `NotOnWhitelistFault` instead. The session's prior state is left
+* unmodified.
+*/
+var SessionInfoAuthenticationFault = class extends TeslaFleetError {
+	static message = "Session info reply failed authentication and was discarded.";
+};
+/**
+* A signed command response reused a counter value already seen on this session.
+*
+* protocol.md requires rejecting a response whose counter has previously
+* been used, to prevent an attacker from replaying a captured encrypted
+* response back at the client.
+*/
+var SignedCommandResponseReplayed = class extends TeslaFleetError {
+	static message = "Signed command response reused an already-seen counter; discarded as a replay.";
+};
+/**
+* Vehicle has responded with an error when sending a signed command
+*/
+var TeslaFleetInformationFault = class extends TeslaFleetError {
+	static message = "Vehicle has responded with an error when sending a signed command";
+};
+/**
+* Unknown fault on signed command.
+*/
+var UnknownFault = class extends TeslaFleetInformationFault {
+	static message = "Unknown fault on signed command.";
+	static code = 1;
+};
+/**
+* Not on whitelist fault on signed command.
+*/
+var NotOnWhitelistFault = class extends TeslaFleetInformationFault {
+	static message = "Not on whitelist fault on signed command.";
+	static code = 2;
+};
+/**
+* IV smaller than expected fault on signed command.
+*/
+var IVSmallerThanExpectedFault = class extends TeslaFleetInformationFault {
+	static message = "IV smaller than expected fault on signed command.";
+	static code = 3;
+};
+/**
+* Invalid token fault on signed command.
+*/
+var InvalidTokenFault = class extends TeslaFleetInformationFault {
+	static message = "Invalid token fault on signed command.";
+	static code = 4;
+};
+/**
+* Token and counter invalid fault on signed command.
+*/
+var TokenAndCounterInvalidFault = class extends TeslaFleetInformationFault {
+	static message = "Token and counter invalid fault on signed command.";
+	static code = 5;
+};
+/**
+* AES decrypt auth fault on signed command.
+*/
+var AESDecryptAuthFault = class extends TeslaFleetInformationFault {
+	static message = "AES decrypt auth fault on signed command.";
+	static code = 6;
+};
+/**
+* ECDSA input fault on signed command.
+*/
+var ECDSAInputFault = class extends TeslaFleetInformationFault {
+	static message = "ECDSA input fault on signed command.";
+	static code = 7;
+};
+/**
+* ECDSA signature fault on signed command.
+*/
+var ECDSASignatureFault = class extends TeslaFleetInformationFault {
+	static message = "ECDSA signature fault on signed command.";
+	static code = 8;
+};
+/**
+* Local entity start fault on signed command.
+*/
+var LocalEntityStartFault = class extends TeslaFleetInformationFault {
+	static message = "Local entity start fault on signed command.";
+	static code = 9;
+};
+/**
+* Local entity result fault on signed command.
+*/
+var LocalEntityResultFault = class extends TeslaFleetInformationFault {
+	static message = "Local entity result fault on signed command.";
+	static code = 10;
+};
+/**
+* Could not retrieve key fault on signed command.
+*/
+var CouldNotRetrieveKeyFault = class extends TeslaFleetInformationFault {
+	static message = "Could not retrieve key fault on signed command.";
+	static code = 11;
+};
+/**
+* Could not retrieve token fault on signed command.
+*/
+var CouldNotRetrieveTokenFault = class extends TeslaFleetInformationFault {
+	static message = "Could not retrieve token fault on signed command.";
+	static code = 12;
+};
+/**
+* Signature too short fault on signed command.
+*/
+var SignatureTooShortFault = class extends TeslaFleetInformationFault {
+	static message = "Signature too short fault on signed command.";
+	static code = 13;
+};
+/**
+* Token is incorrect length fault on signed command.
+*/
+var TokenIsIncorrectLengthFault = class extends TeslaFleetInformationFault {
+	static message = "Token is incorrect length fault on signed command.";
+	static code = 14;
+};
+/**
+* Incorrect epoch fault on signed command.
+*/
+var IncorrectEpochFault = class extends TeslaFleetInformationFault {
+	static message = "Incorrect epoch fault on signed command.";
+	static code = 15;
+};
+/**
+* IV incorrect length fault on signed command.
+*/
+var IVIncorrectLengthFault = class extends TeslaFleetInformationFault {
+	static message = "IV incorrect length fault on signed command.";
+	static code = 16;
+};
+/**
+* Time expired fault on signed command.
+*/
+var TimeExpiredFault = class extends TeslaFleetInformationFault {
+	static message = "Time expired fault on signed command.";
+	static code = 17;
+};
+/**
+* Not provisioned with identity fault on signed command.
+*/
+var NotProvisionedWithIdentityFault = class extends TeslaFleetInformationFault {
+	static message = "Not provisioned with identity fault on signed command.";
+	static code = 18;
+};
+/**
+* Could not hash metadata fault on signed command.
+*/
+var CouldNotHashMetadataFault = class extends TeslaFleetInformationFault {
+	static message = "Could not hash metadata fault on signed command.";
+	static code = 19;
+};
+/**
+* Vehicle has responded with an error when sending a signed command
+*/
+var TeslaFleetMessageFault = class extends TeslaFleetError {
+	static message = "Vehicle has responded with an error when sending a signed command";
+};
+/**
+* Required vehicle subsystem is busy. Try again
+*/
+var TeslaFleetMessageFaultBusy = class extends TeslaFleetMessageFault {
+	static message = "Required vehicle subsystem is busy. Try again";
+	static code = 1;
+};
+/**
+* Vehicle subsystem did not respond. Try again
+*/
+var TeslaFleetMessageFaultTimeout = class extends TeslaFleetMessageFault {
+	static message = "Vehicle subsystem did not respond. Try again";
+	static code = 2;
+};
+/**
+* Vehicle did not recognize the key used to authorize command. Make sure your key is paired with the vehicle
+*/
+var TeslaFleetMessageFaultUnknownKeyId = class extends TeslaFleetMessageFault {
+	static message = "Vehicle did not recognize the key used to authorize command. Make sure your key is paired with the vehicle";
+	static code = 3;
+};
+/**
+* Key used to authorize command has been disabled
+*/
+var TeslaFleetMessageFaultInactiveKey = class extends TeslaFleetMessageFault {
+	static message = "Key used to authorize command has been disabled";
+	static code = 4;
+};
+/**
+* Command signature/MAC is incorrect. Use included session info to update session and try again
+*/
+var TeslaFleetMessageFaultInvalidSignature = class extends TeslaFleetMessageFault {
+	static message = "Command signature/MAC is incorrect. Use included session info to update session and try again";
+	static code = 5;
+};
+/**
+* Command anti-replay counter has been used before. Use included session info to update session and try again
+*/
+var TeslaFleetMessageFaultInvalidTokenOrCounter = class extends TeslaFleetMessageFault {
+	static message = "Command anti-replay counter has been used before. Use included session info to update session and try again";
+	static code = 6;
+};
+/**
+* User is not authorized to execute command. This can be because of the role or because of vehicle state
+*/
+var TeslaFleetMessageFaultInsufficientPrivileges = class extends TeslaFleetMessageFault {
+	static message = "User is not authorized to execute command. This can be because of the role or because of vehicle state";
+	static code = 7;
+};
+/**
+* Command was malformed or addressed to an unrecognized vehicle system. May indicate client error or older vehicle firmware
+*/
+var TeslaFleetMessageFaultInvalidDomains = class extends TeslaFleetMessageFault {
+	static message = "Command was malformed or addressed to an unrecognized vehicle system. May indicate client error or older vehicle firmware";
+	static code = 8;
+};
+/**
+* Unrecognized command. May indicate client error or unsupported vehicle firmware
+*/
+var TeslaFleetMessageFaultInvalidCommand = class extends TeslaFleetMessageFault {
+	static message = "Unrecognized command. May indicate client error or unsupported vehicle firmware";
+	static code = 9;
+};
+/**
+* Could not parse command. Indicates client error
+*/
+var TeslaFleetMessageFaultDecoding = class extends TeslaFleetMessageFault {
+	static message = "Could not parse command. Indicates client error";
+	static code = 10;
+};
+/**
+* Internal vehicle error. Try again. Most commonly encountered when the vehicle has not finished booting
+*/
+var TeslaFleetMessageFaultInternal = class extends TeslaFleetMessageFault {
+	static message = "Internal vehicle error. Try again. Most commonly encountered when the vehicle has not finished booting";
+	static code = 11;
+};
+/**
+* Command sent to wrong VIN
+*/
+var TeslaFleetMessageFaultWrongPersonalization = class extends TeslaFleetMessageFault {
+	static message = "Command sent to wrong VIN";
+	static code = 12;
+};
+/**
+* Command was malformed or used a deprecated parameter
+*/
+var TeslaFleetMessageFaultBadParameter = class extends TeslaFleetMessageFault {
+	static message = "Command was malformed or used a deprecated parameter";
+	static code = 13;
+};
+/**
+* Vehicle's keychain is full. You must delete a key before you can add another
+*/
+var TeslaFleetMessageFaultKeychainIsFull = class extends TeslaFleetMessageFault {
+	static message = "Vehicle's keychain is full. You must delete a key before you can add another";
+	static code = 14;
+};
+/**
+* Session ID mismatch. Use included session info to update session and try again
+*/
+var TeslaFleetMessageFaultIncorrectEpoch = class extends TeslaFleetMessageFault {
+	static message = "Session ID mismatch. Use included session info to update session and try again";
+	static code = 15;
+};
+/**
+* Initialization Value length is incorrect (AES-GCM must use 12-byte IVs). Indicates a client programming error
+*/
+var TeslaFleetMessageFaultIVIncorrectLength = class extends TeslaFleetMessageFault {
+	static message = "Initialization Value length is incorrect (AES-GCM must use 12-byte IVs). Indicates a client programming error";
+	static code = 16;
+};
+/**
+* Command expired. Use included session info to determine if clocks have desynchronized and try again
+*/
+var TeslaFleetMessageFaultTimeExpired = class extends TeslaFleetMessageFault {
+	static message = "Command expired. Use included session info to determine if clocks have desynchronized and try again";
+	static code = 17;
+};
+/**
+* Vehicle has not been provisioned with a VIN and may require service
+*/
+var TeslaFleetMessageFaultNotProvisionedWithIdentity = class extends TeslaFleetMessageFault {
+	static message = "Vehicle has not been provisioned with a VIN and may require service";
+	static code = 18;
+};
+/**
+* Internal vehicle error
+*/
+var TeslaFleetMessageFaultCouldNotHashMetadata = class extends TeslaFleetMessageFault {
+	static message = "Internal vehicle error";
+	static code = 19;
+};
+/**
+* Vehicle rejected command because its expiration time was too far in the future. This is a security precaution
+*/
+var TeslaFleetMessageFaultTimeToLiveTooLong = class extends TeslaFleetMessageFault {
+	static message = "Vehicle rejected command because its expiration time was too far in the future. This is a security precaution";
+	static code = 20;
+};
+/**
+* The vehicle owner has disabled Mobile access
+*/
+var TeslaFleetMessageFaultRemoteAccessDisabled = class extends TeslaFleetMessageFault {
+	static message = "The vehicle owner has disabled Mobile access";
+	static code = 21;
+};
+/**
+* The command was authorized with a Service key, but the vehicle has not been configured to permit remote service commands
+*/
+var TeslaFleetMessageFaultRemoteServiceAccessDisabled = class extends TeslaFleetMessageFault {
+	static message = "The command was authorized with a Service key, but the vehicle has not been configured to permit remote service commands";
+	static code = 22;
+};
+/**
+* The command requires proof of Tesla account credentials but was not sent over a channel that provides this proof. Resend the command using Fleet API
+*/
+var TeslaFleetMessageFaultCommandRequiresAccountCredentials = class extends TeslaFleetMessageFault {
+	static message = "The command requires proof of Tesla account credentials but was not sent over a channel that provides this proof. Resend the command using Fleet API";
+	static code = 23;
+};
+/**
+* Client sent a request with a field that exceeds MTU
+*/
+var TeslaFleetMessageFaultFieldExceedsMTU = class extends TeslaFleetMessageFault {
+	static message = "Client sent a request with a field that exceeds MTU";
+	static code = 24;
+};
+/**
+* Client's request was received, but response size exceeded MTU
+*/
+var TeslaFleetMessageFaultResponseSizeExceedsMTU = class extends TeslaFleetMessageFault {
+	static message = "Client's request was received, but response size exceeded MTU";
+	static code = 25;
+};
+/**
+* The vehicle has seen this counter value before. Reset the counter and try again
+*/
+var TeslaFleetMessageFaultRepeatedCounter = class extends TeslaFleetMessageFault {
+	static message = "The vehicle has seen this counter value before. Reset the counter and try again";
+	static code = 26;
+};
+/**
+* The key handle is not valid. The key may have been revoked or expired
+*/
+var TeslaFleetMessageFaultInvalidKeyHandle = class extends TeslaFleetMessageFault {
+	static message = "The key handle is not valid. The key may have been revoked or expired";
+	static code = 27;
+};
+/**
+* The response requires encryption but encryption was not requested
+*/
+var TeslaFleetMessageFaultRequiresResponseEncryption = class extends TeslaFleetMessageFault {
+	static message = "The response requires encryption but encryption was not requested";
+	static code = 28;
+};
+/**
+* Vehicle has responded with an error when sending a signed command
+*/
+var SignedMessageInformationFault = class extends TeslaFleetError {
+	static message = "Vehicle has responded with an error when sending a signed command";
+};
+/**
+* Unknown fault on signed command.
+*/
+var SignedMessageInformationFaultUnknown = class extends SignedMessageInformationFault {
+	static message = "Unknown fault on signed command.";
+	static code = 1;
+};
+/**
+* Not on whitelist fault on signed command.
+*/
+var SignedMessageInformationFaultNotOnWhitelist = class extends SignedMessageInformationFault {
+	static message = "Not on whitelist fault on signed command.";
+	static code = 2;
+};
+/**
+* IV smaller than expected fault on signed command.
+*/
+var SignedMessageInformationFaultIVSmallerThanExpected = class extends SignedMessageInformationFault {
+	static message = "IV smaller than expected fault on signed command.";
+	static code = 3;
+};
+/**
+* Invalid token fault on signed command.
+*/
+var SignedMessageInformationFaultInvalidToken = class extends SignedMessageInformationFault {
+	static message = "Invalid token fault on signed command.";
+	static code = 4;
+};
+/**
+* Token and counter invalid fault on signed command.
+*/
+var SignedMessageInformationFaultTokenAndCounterInvalid = class extends SignedMessageInformationFault {
+	static message = "Token and counter invalid fault on signed command.";
+	static code = 5;
+};
+/**
+* AES decrypt auth fault on signed command.
+*/
+var SignedMessageInformationFaultAESDecryptAuth = class extends SignedMessageInformationFault {
+	static message = "AES decrypt auth fault on signed command.";
+	static code = 6;
+};
+/**
+* ECDSA input fault on signed command.
+*/
+var SignedMessageInformationFaultECDSAInput = class extends SignedMessageInformationFault {
+	static message = "ECDSA input fault on signed command.";
+	static code = 7;
+};
+/**
+* ECDSA signature fault on signed command.
+*/
+var SignedMessageInformationFaultECDSASignature = class extends SignedMessageInformationFault {
+	static message = "ECDSA signature fault on signed command.";
+	static code = 8;
+};
+/**
+* Local entity start fault on signed command.
+*/
+var SignedMessageInformationFaultLocalEntityStart = class extends SignedMessageInformationFault {
+	static message = "Local entity start fault on signed command.";
+	static code = 9;
+};
+/**
+* Local entity result fault on signed command.
+*/
+var SignedMessageInformationFaultLocalEntityResult = class extends SignedMessageInformationFault {
+	static message = "Local entity result fault on signed command.";
+	static code = 10;
+};
+/**
+* Could not retrieve key fault on signed command.
+*/
+var SignedMessageInformationFaultCouldNotRetrieveKey = class extends SignedMessageInformationFault {
+	static message = "Could not retrieve key fault on signed command.";
+	static code = 11;
+};
+/**
+* Could not retrieve token fault on signed command.
+*/
+var SignedMessageInformationFaultCouldNotRetrieveToken = class extends SignedMessageInformationFault {
+	static message = "Could not retrieve token fault on signed command.";
+	static code = 12;
+};
+/**
+* Signature too short fault on signed command.
+*/
+var SignedMessageInformationFaultSignatureTooShort = class extends SignedMessageInformationFault {
+	static message = "Signature too short fault on signed command.";
+	static code = 13;
+};
+/**
+* Token is incorrect length fault on signed command.
+*/
+var SignedMessageInformationFaultTokenIsIncorrectLength = class extends SignedMessageInformationFault {
+	static message = "Token is incorrect length fault on signed command.";
+	static code = 14;
+};
+/**
+* Incorrect epoch fault on signed command.
+*/
+var SignedMessageInformationFaultIncorrectEpoch = class extends SignedMessageInformationFault {
+	static message = "Incorrect epoch fault on signed command.";
+	static code = 15;
+};
+/**
+* IV incorrect length fault on signed command.
+*/
+var SignedMessageInformationFaultIVIncorrectLength = class extends SignedMessageInformationFault {
+	static message = "IV incorrect length fault on signed command.";
+	static code = 16;
+};
+/**
+* Time expired fault on signed command.
+*/
+var SignedMessageInformationFaultTimeExpired = class extends SignedMessageInformationFault {
+	static message = "Time expired fault on signed command.";
+	static code = 17;
+};
+/**
+* Not provisioned with identity fault on signed command.
+*/
+var SignedMessageInformationFaultNotProvisionedWithIdentity = class extends SignedMessageInformationFault {
+	static message = "Not provisioned with identity fault on signed command.";
+	static code = 18;
+};
+/**
+* Could not hash metadata fault on signed command.
+*/
+var SignedMessageInformationFaultCouldNotHashMetadata = class extends SignedMessageInformationFault {
+	static message = "Could not hash metadata fault on signed command.";
+	static code = 19;
+};
+var WhitelistOperationStatus = class extends TeslaFleetError {
+	static message = "Whitelist operation failed";
+};
+var WhitelistOperationUndocumentedError = class extends WhitelistOperationStatus {
+	static message = "Undocumented whitelist operation error";
+	static code = 1;
+};
+var WhitelistOperationNoPermissionToRemoveOneself = class extends WhitelistOperationStatus {
+	static message = "No permission to remove oneself from whitelist";
+	static code = 2;
+};
+var WhitelistOperationKeyfobSlotsFull = class extends WhitelistOperationStatus {
+	static message = "Keyfob slots are full";
+	static code = 3;
+};
+var WhitelistOperationWhitelistFull = class extends WhitelistOperationStatus {
+	static message = "Whitelist is full";
+	static code = 4;
+};
+var WhitelistOperationNoPermissionToAdd = class extends WhitelistOperationStatus {
+	static message = "No permission to add to whitelist";
+	static code = 5;
+};
+var WhitelistOperationInvalidPublicKey = class extends WhitelistOperationStatus {
+	static message = "Invalid public key";
+	static code = 6;
+};
+var WhitelistOperationNoPermissionToRemove = class extends WhitelistOperationStatus {
+	static message = "No permission to remove from whitelist";
+	static code = 7;
+};
+var WhitelistOperationNoPermissionToChangePermissions = class extends WhitelistOperationStatus {
+	static message = "No permission to change permissions";
+	static code = 8;
+};
+var WhitelistOperationAttemptingToElevateOthersAboveOneself = class extends WhitelistOperationStatus {
+	static message = "Attempting to elevate others above oneself";
+	static code = 9;
+};
+var WhitelistOperationAttemptingToDemoteSuperiorToOneself = class extends WhitelistOperationStatus {
+	static message = "Attempting to demote superior to oneself";
+	static code = 10;
+};
+var WhitelistOperationAttemptingToRemoveOwnPermissions = class extends WhitelistOperationStatus {
+	static message = "Attempting to remove own permissions";
+	static code = 11;
+};
+var WhitelistOperationPublicKeyNotOnWhitelist = class extends WhitelistOperationStatus {
+	static message = "Public key not on whitelist";
+	static code = 12;
+};
+var WhitelistOperationAttemptingToAddExistingKey = class extends WhitelistOperationStatus {
+	static message = "Attempting to add key that is already on the whitelist";
+	static code = 13;
+};
+var WhitelistOperationNotAllowedToAddUnlessOnReader = class extends WhitelistOperationStatus {
+	static message = "Not allowed to add unless on reader";
+	static code = 14;
+};
+var WhitelistOperationFMModifyingOutsideOfFMode = class extends WhitelistOperationStatus {
+	static message = "FM modifying outside of F mode";
+	static code = 15;
+};
+var WhitelistOperationFMAttemptingToAddPermanentKey = class extends WhitelistOperationStatus {
+	static message = "FM attempting to add permanent key";
+	static code = 16;
+};
+var WhitelistOperationFMAttemptingToRemovePermanentKey = class extends WhitelistOperationStatus {
+	static message = "FM attempting to remove permanent key";
+	static code = 17;
+};
+var WhitelistOperationKeychainWhileFSFull = class extends WhitelistOperationStatus {
+	static message = "Keychain while FS full";
+	static code = 18;
+};
+var WhitelistOperationAttemptingToAddKeyWithoutRole = class extends WhitelistOperationStatus {
+	static message = "Attempting to add key without role";
+	static code = 19;
+};
+var WhitelistOperationAttemptingToAddKeyWithServiceRole = class extends WhitelistOperationStatus {
+	static message = "Attempting to add key with service role";
+	static code = 20;
+};
+var WhitelistOperationNonServiceKeyAttemptingToAddServiceTech = class extends WhitelistOperationStatus {
+	static message = "Non-service key attempting to add service tech";
+	static code = 21;
+};
+var WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode = class extends WhitelistOperationStatus {
+	static message = "Service key attempting to add service tech outside service mode";
+	static code = 22;
+};
+var WhitelistOperationCouldNotStartLocalEntityAuth = class extends WhitelistOperationStatus {
+	static message = "Could not start local entity authentication";
+	static code = 23;
+};
+var WhitelistOperationLocalEntityAuthFailedUIDenied = class extends WhitelistOperationStatus {
+	static message = "Local entity authentication failed - UI denied";
+	static code = 24;
+};
+var WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForTap = class extends WhitelistOperationStatus {
+	static message = "Authorization request timed out";
+	static code = 25;
+};
+var WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForUIAck = class extends WhitelistOperationStatus {
+	static message = "Local entity authentication failed - timed out waiting for UI acknowledgement";
+	static code = 26;
+};
+var WhitelistOperationLocalEntityAuthFailedValetMode = class extends WhitelistOperationStatus {
+	static message = "Local entity authentication failed - valet mode";
+	static code = 27;
+};
+var WhitelistOperationLocalEntityAuthFailedCancelled = class extends WhitelistOperationStatus {
+	static message = "Local entity authentication failed - cancelled";
+	static code = 28;
+};
+/** `TeslaFleetInformationFault` subclasses indexed by their protobuf enum value; index 0 (no fault) is `null`. */
+const INFORMATION_FAULTS = [
+	null,
+	UnknownFault,
+	NotOnWhitelistFault,
+	IVSmallerThanExpectedFault,
+	InvalidTokenFault,
+	TokenAndCounterInvalidFault,
+	AESDecryptAuthFault,
+	ECDSAInputFault,
+	ECDSASignatureFault,
+	LocalEntityStartFault,
+	LocalEntityResultFault,
+	CouldNotRetrieveKeyFault,
+	CouldNotRetrieveTokenFault,
+	SignatureTooShortFault,
+	TokenIsIncorrectLengthFault,
+	IncorrectEpochFault,
+	IVIncorrectLengthFault,
+	TimeExpiredFault,
+	NotProvisionedWithIdentityFault,
+	CouldNotHashMetadataFault
+];
+/** `TeslaFleetMessageFault` subclasses indexed by their protobuf enum value; index 0 (no fault) is `null`. */
+const MESSAGE_FAULTS = [
+	null,
+	TeslaFleetMessageFaultBusy,
+	TeslaFleetMessageFaultTimeout,
+	TeslaFleetMessageFaultUnknownKeyId,
+	TeslaFleetMessageFaultInactiveKey,
+	TeslaFleetMessageFaultInvalidSignature,
+	TeslaFleetMessageFaultInvalidTokenOrCounter,
+	TeslaFleetMessageFaultInsufficientPrivileges,
+	TeslaFleetMessageFaultInvalidDomains,
+	TeslaFleetMessageFaultInvalidCommand,
+	TeslaFleetMessageFaultDecoding,
+	TeslaFleetMessageFaultInternal,
+	TeslaFleetMessageFaultWrongPersonalization,
+	TeslaFleetMessageFaultBadParameter,
+	TeslaFleetMessageFaultKeychainIsFull,
+	TeslaFleetMessageFaultIncorrectEpoch,
+	TeslaFleetMessageFaultIVIncorrectLength,
+	TeslaFleetMessageFaultTimeExpired,
+	TeslaFleetMessageFaultNotProvisionedWithIdentity,
+	TeslaFleetMessageFaultCouldNotHashMetadata,
+	TeslaFleetMessageFaultTimeToLiveTooLong,
+	TeslaFleetMessageFaultRemoteAccessDisabled,
+	TeslaFleetMessageFaultRemoteServiceAccessDisabled,
+	TeslaFleetMessageFaultCommandRequiresAccountCredentials,
+	TeslaFleetMessageFaultFieldExceedsMTU,
+	TeslaFleetMessageFaultResponseSizeExceedsMTU,
+	TeslaFleetMessageFaultRepeatedCounter,
+	TeslaFleetMessageFaultInvalidKeyHandle,
+	TeslaFleetMessageFaultRequiresResponseEncryption
+];
+/** `SignedMessageInformationFault` subclasses indexed by their protobuf enum value; index 0 (no fault) is `null`. */
+const SIGNED_MESSAGE_INFORMATION_FAULTS = [
+	null,
+	SignedMessageInformationFaultUnknown,
+	SignedMessageInformationFaultNotOnWhitelist,
+	SignedMessageInformationFaultIVSmallerThanExpected,
+	SignedMessageInformationFaultInvalidToken,
+	SignedMessageInformationFaultTokenAndCounterInvalid,
+	SignedMessageInformationFaultAESDecryptAuth,
+	SignedMessageInformationFaultECDSAInput,
+	SignedMessageInformationFaultECDSASignature,
+	SignedMessageInformationFaultLocalEntityStart,
+	SignedMessageInformationFaultLocalEntityResult,
+	SignedMessageInformationFaultCouldNotRetrieveKey,
+	SignedMessageInformationFaultCouldNotRetrieveToken,
+	SignedMessageInformationFaultSignatureTooShort,
+	SignedMessageInformationFaultTokenIsIncorrectLength,
+	SignedMessageInformationFaultIncorrectEpoch,
+	SignedMessageInformationFaultIVIncorrectLength,
+	SignedMessageInformationFaultTimeExpired,
+	SignedMessageInformationFaultNotProvisionedWithIdentity,
+	SignedMessageInformationFaultCouldNotHashMetadata
+];
+/** `WhitelistOperationStatus` subclasses indexed by their protobuf enum value; index 0 (no fault) is `null`. */
+const WHITELIST_OPERATION_STATUS = [
+	null,
+	WhitelistOperationUndocumentedError,
+	WhitelistOperationNoPermissionToRemoveOneself,
+	WhitelistOperationKeyfobSlotsFull,
+	WhitelistOperationWhitelistFull,
+	WhitelistOperationNoPermissionToAdd,
+	WhitelistOperationInvalidPublicKey,
+	WhitelistOperationNoPermissionToRemove,
+	WhitelistOperationNoPermissionToChangePermissions,
+	WhitelistOperationAttemptingToElevateOthersAboveOneself,
+	WhitelistOperationAttemptingToDemoteSuperiorToOneself,
+	WhitelistOperationAttemptingToRemoveOwnPermissions,
+	WhitelistOperationPublicKeyNotOnWhitelist,
+	WhitelistOperationAttemptingToAddExistingKey,
+	WhitelistOperationNotAllowedToAddUnlessOnReader,
+	WhitelistOperationFMModifyingOutsideOfFMode,
+	WhitelistOperationFMAttemptingToAddPermanentKey,
+	WhitelistOperationFMAttemptingToRemovePermanentKey,
+	WhitelistOperationKeychainWhileFSFull,
+	WhitelistOperationAttemptingToAddKeyWithoutRole,
+	WhitelistOperationAttemptingToAddKeyWithServiceRole,
+	WhitelistOperationNonServiceKeyAttemptingToAddServiceTech,
+	WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode,
+	WhitelistOperationCouldNotStartLocalEntityAuth,
+	WhitelistOperationLocalEntityAuthFailedUIDenied,
+	WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForTap,
+	WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForUIAck,
+	WhitelistOperationLocalEntityAuthFailedValetMode,
+	WhitelistOperationLocalEntityAuthFailedCancelled
+];
+/**
+* Every fault a vehicle can return that means it did not recognize/accept our
+* signing key as authorized to issue commands, verified against each fault's
+* proto enum meaning rather than its name alone.
+* `TeslaFleetMessageFaultKeychainIsFull` is deliberately excluded: its proto
+* meaning is "no room to add another key", not "this key was rejected".
+*/
+const KEY_REJECTED_FAULTS = [
+	NotOnWhitelistFault,
+	CouldNotRetrieveKeyFault,
+	SignedMessageInformationFaultNotOnWhitelist,
+	SignedMessageInformationFaultCouldNotRetrieveKey,
+	TeslaFleetMessageFaultUnknownKeyId,
+	TeslaFleetMessageFaultInactiveKey,
+	TeslaFleetMessageFaultInvalidKeyHandle
+];
+/**
+* Whether `error` means the vehicle rejected our signing key.
+*
+* True for a fault meaning the vehicle does not recognize our key as
+* whitelisted/paired (or could not retrieve/validate it), false for every
+* other fault, including transport errors and faults about an unrelated
+* signed-command condition (e.g. a full keychain).
+*/
+function is_key_rejected(error) {
+	return KEY_REJECTED_FAULTS.some((cls) => error instanceof cls);
+}
+function keyed(error, candidates) {
+	return error ? candidates.find((cls) => cls.key === error) : void 0;
+}
+/**
+* Throw the `TeslaFleetError` subclass matching `resp` if its status is >= 400.
+* https://developer.tesla.com/docs/fleet-api#response-codes
+*
+* Consumes the response body when it throws; resolves without touching the
+* body otherwise.
+*/
+async function raise_for_status(resp) {
+	if (resp.status < 400) return;
+	const text = await resp.text();
+	let data = null;
+	if (resp.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() === "application/json") try {
+		const parsed = JSON.parse(text);
+		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) data = parsed;
+	} catch {}
+	const error = data?.error;
+	switch (resp.status) {
+		case 400: throw new ((keyed(error, [
+			InvalidCommand,
+			InvalidField,
+			InvalidRequest,
+			InvalidAuthCode,
+			InvalidRedirectUrl,
+			UnauthorizedClient
+		])) ?? InvalidRequest)(data);
+		case 401: {
+			const cls = keyed(error, [
+				OAuthExpired,
+				MobileAccessDisabled,
+				LoginRequired,
+				MissingTeslemetryToken,
+				MissingTessieToken,
+				InvalidTeslemetryToken,
+				InvalidTessieToken
+			]);
+			if (cls) throw new cls(data);
+			throw new OAuthExpired();
+		}
+		case 402: throw new ((keyed(error, [
+			SubscriptionRequired,
+			VehicleSubscriptionRequired,
+			InsufficientCredits
+		])) ?? PaymentRequired)(data);
+		case 403: throw new ((keyed(error, [InvalidScope, UnsupportedVehicle])) ?? Forbidden)(data);
+		case 404: throw new NotFound(data);
+		case 405: throw new (error === InvalidMethod.key ? InvalidMethod : NotAllowed)(data);
+		case 406: throw new NotAcceptable(data);
+		case 408: throw new VehicleOffline(data);
+		case 412: throw new PreconditionFailed(data);
+		case 421: throw new InvalidRegion(data);
+		case 422: throw new InvalidResource(data);
+		case 423: throw new Locked(data);
+		case 424: throw new InvalidResponse(data);
+		case 429: throw new RateLimited({
+			reset: resp.headers.get("RateLimit-Reset"),
+			after: resp.headers.get("Retry-After")
+		});
+		case 451: throw new ResourceUnavailableForLegalReasons(data);
+		case 499: throw new ClientClosedRequest(data);
+		case 500: throw new InternalServerError(data);
+		case 502: throw new (error === EnergyGatewayUnreachable.key ? EnergyGatewayUnreachable : BadGateway)(data);
+		case 503: throw new ServiceUnavailable(data);
+		case 504: throw new GatewayTimeout(data);
+		case 540: throw new DeviceUnexpectedResponse(data);
+	}
+	if (data === null) throw new ResponseError(text, resp.status);
+	throw new TeslaFleetError(data, resp.status);
+}
+exports.AESDecryptAuthFault = AESDecryptAuthFault;
+exports.AuthorizedClientPairingTimedOut = AuthorizedClientPairingTimedOut;
+exports.AuthorizedClientWaitExpired = AuthorizedClientWaitExpired;
+exports.BadGateway = BadGateway;
+exports.BluetoothCloudUnavailableError = BluetoothCloudUnavailableError;
+exports.BluetoothCommandFailed = BluetoothCommandFailed;
+exports.BluetoothTimeout = BluetoothTimeout;
+exports.BluetoothTransportError = BluetoothTransportError;
+exports.BluetoothUnconfirmedCommand = BluetoothUnconfirmedCommand;
+exports.ClientClosedRequest = ClientClosedRequest;
+exports.CouldNotHashMetadataFault = CouldNotHashMetadataFault;
+exports.CouldNotRetrieveKeyFault = CouldNotRetrieveKeyFault;
+exports.CouldNotRetrieveTokenFault = CouldNotRetrieveTokenFault;
+exports.DeviceUnexpectedResponse = DeviceUnexpectedResponse;
+exports.ECDSAInputFault = ECDSAInputFault;
+exports.ECDSASignatureFault = ECDSASignatureFault;
+exports.EnergyGatewayUnreachable = EnergyGatewayUnreachable;
+exports.Forbidden = Forbidden;
+exports.GatewayTimeout = GatewayTimeout;
+exports.INFORMATION_FAULTS = INFORMATION_FAULTS;
+exports.IVIncorrectLengthFault = IVIncorrectLengthFault;
+exports.IVSmallerThanExpectedFault = IVSmallerThanExpectedFault;
+exports.IncorrectEpochFault = IncorrectEpochFault;
+exports.InsufficientCredits = InsufficientCredits;
+exports.InternalServerError = InternalServerError;
+exports.InvalidAuthCode = InvalidAuthCode;
+exports.InvalidCommand = InvalidCommand;
+exports.InvalidField = InvalidField;
+exports.InvalidMethod = InvalidMethod;
+exports.InvalidRedirectUrl = InvalidRedirectUrl;
+exports.InvalidRegion = InvalidRegion;
+exports.InvalidRequest = InvalidRequest;
+exports.InvalidResource = InvalidResource;
+exports.InvalidResponse = InvalidResponse;
+exports.InvalidScope = InvalidScope;
+exports.InvalidTeslemetryToken = InvalidTeslemetryToken;
+exports.InvalidTessieToken = InvalidTessieToken;
+exports.InvalidToken = InvalidToken;
+exports.InvalidTokenFault = InvalidTokenFault;
+exports.KEY_REJECTED_FAULTS = KEY_REJECTED_FAULTS;
+exports.LibraryError = LibraryError;
+exports.LocalEntityResultFault = LocalEntityResultFault;
+exports.LocalEntityStartFault = LocalEntityStartFault;
+exports.Locked = Locked;
+exports.LoginRequired = LoginRequired;
+exports.MESSAGE_FAULTS = MESSAGE_FAULTS;
+exports.MissingTeslemetryToken = MissingTeslemetryToken;
+exports.MissingTessieToken = MissingTessieToken;
+exports.MissingToken = MissingToken;
+exports.MobileAccessDisabled = MobileAccessDisabled;
+exports.NotAcceptable = NotAcceptable;
+exports.NotAllowed = NotAllowed;
+exports.NotFound = NotFound;
+exports.NotOnWhitelistFault = NotOnWhitelistFault;
+exports.NotProvisionedWithIdentityFault = NotProvisionedWithIdentityFault;
+exports.OAuthExpired = OAuthExpired;
+exports.OAuthInvalid = OAuthInvalid;
+exports.PaymentRequired = PaymentRequired;
+exports.PreconditionFailed = PreconditionFailed;
+exports.PrivateKeyError = PrivateKeyError;
+exports.RateLimited = RateLimited;
+exports.ResourceUnavailableForLegalReasons = ResourceUnavailableForLegalReasons;
+exports.ResponseError = ResponseError;
+exports.SIGNED_MESSAGE_INFORMATION_FAULTS = SIGNED_MESSAGE_INFORMATION_FAULTS;
+exports.ServiceUnavailable = ServiceUnavailable;
+exports.SessionInfoAuthenticationFault = SessionInfoAuthenticationFault;
+exports.SignatureTooShortFault = SignatureTooShortFault;
+exports.SignedCommandRequired = SignedCommandRequired;
+exports.SignedCommandResponseReplayed = SignedCommandResponseReplayed;
+exports.SignedMessageInformationFault = SignedMessageInformationFault;
+exports.SignedMessageInformationFaultAESDecryptAuth = SignedMessageInformationFaultAESDecryptAuth;
+exports.SignedMessageInformationFaultCouldNotHashMetadata = SignedMessageInformationFaultCouldNotHashMetadata;
+exports.SignedMessageInformationFaultCouldNotRetrieveKey = SignedMessageInformationFaultCouldNotRetrieveKey;
+exports.SignedMessageInformationFaultCouldNotRetrieveToken = SignedMessageInformationFaultCouldNotRetrieveToken;
+exports.SignedMessageInformationFaultECDSAInput = SignedMessageInformationFaultECDSAInput;
+exports.SignedMessageInformationFaultECDSASignature = SignedMessageInformationFaultECDSASignature;
+exports.SignedMessageInformationFaultIVIncorrectLength = SignedMessageInformationFaultIVIncorrectLength;
+exports.SignedMessageInformationFaultIVSmallerThanExpected = SignedMessageInformationFaultIVSmallerThanExpected;
+exports.SignedMessageInformationFaultIncorrectEpoch = SignedMessageInformationFaultIncorrectEpoch;
+exports.SignedMessageInformationFaultInvalidToken = SignedMessageInformationFaultInvalidToken;
+exports.SignedMessageInformationFaultLocalEntityResult = SignedMessageInformationFaultLocalEntityResult;
+exports.SignedMessageInformationFaultLocalEntityStart = SignedMessageInformationFaultLocalEntityStart;
+exports.SignedMessageInformationFaultNotOnWhitelist = SignedMessageInformationFaultNotOnWhitelist;
+exports.SignedMessageInformationFaultNotProvisionedWithIdentity = SignedMessageInformationFaultNotProvisionedWithIdentity;
+exports.SignedMessageInformationFaultSignatureTooShort = SignedMessageInformationFaultSignatureTooShort;
+exports.SignedMessageInformationFaultTimeExpired = SignedMessageInformationFaultTimeExpired;
+exports.SignedMessageInformationFaultTokenAndCounterInvalid = SignedMessageInformationFaultTokenAndCounterInvalid;
+exports.SignedMessageInformationFaultTokenIsIncorrectLength = SignedMessageInformationFaultTokenIsIncorrectLength;
+exports.SignedMessageInformationFaultUnknown = SignedMessageInformationFaultUnknown;
+exports.SigningDisabled = SigningDisabled;
+exports.SubscriptionRequired = SubscriptionRequired;
+exports.TeslaFleetConnectionError = TeslaFleetConnectionError;
+exports.TeslaFleetError = TeslaFleetError;
+exports.TeslaFleetInformationFault = TeslaFleetInformationFault;
+exports.TeslaFleetMessageFault = TeslaFleetMessageFault;
+exports.TeslaFleetMessageFaultBadParameter = TeslaFleetMessageFaultBadParameter;
+exports.TeslaFleetMessageFaultBusy = TeslaFleetMessageFaultBusy;
+exports.TeslaFleetMessageFaultCommandRequiresAccountCredentials = TeslaFleetMessageFaultCommandRequiresAccountCredentials;
+exports.TeslaFleetMessageFaultCouldNotHashMetadata = TeslaFleetMessageFaultCouldNotHashMetadata;
+exports.TeslaFleetMessageFaultDecoding = TeslaFleetMessageFaultDecoding;
+exports.TeslaFleetMessageFaultFieldExceedsMTU = TeslaFleetMessageFaultFieldExceedsMTU;
+exports.TeslaFleetMessageFaultIVIncorrectLength = TeslaFleetMessageFaultIVIncorrectLength;
+exports.TeslaFleetMessageFaultInactiveKey = TeslaFleetMessageFaultInactiveKey;
+exports.TeslaFleetMessageFaultIncorrectEpoch = TeslaFleetMessageFaultIncorrectEpoch;
+exports.TeslaFleetMessageFaultInsufficientPrivileges = TeslaFleetMessageFaultInsufficientPrivileges;
+exports.TeslaFleetMessageFaultInternal = TeslaFleetMessageFaultInternal;
+exports.TeslaFleetMessageFaultInvalidCommand = TeslaFleetMessageFaultInvalidCommand;
+exports.TeslaFleetMessageFaultInvalidDomains = TeslaFleetMessageFaultInvalidDomains;
+exports.TeslaFleetMessageFaultInvalidKeyHandle = TeslaFleetMessageFaultInvalidKeyHandle;
+exports.TeslaFleetMessageFaultInvalidSignature = TeslaFleetMessageFaultInvalidSignature;
+exports.TeslaFleetMessageFaultInvalidTokenOrCounter = TeslaFleetMessageFaultInvalidTokenOrCounter;
+exports.TeslaFleetMessageFaultKeychainIsFull = TeslaFleetMessageFaultKeychainIsFull;
+exports.TeslaFleetMessageFaultNotProvisionedWithIdentity = TeslaFleetMessageFaultNotProvisionedWithIdentity;
+exports.TeslaFleetMessageFaultRemoteAccessDisabled = TeslaFleetMessageFaultRemoteAccessDisabled;
+exports.TeslaFleetMessageFaultRemoteServiceAccessDisabled = TeslaFleetMessageFaultRemoteServiceAccessDisabled;
+exports.TeslaFleetMessageFaultRepeatedCounter = TeslaFleetMessageFaultRepeatedCounter;
+exports.TeslaFleetMessageFaultRequiresResponseEncryption = TeslaFleetMessageFaultRequiresResponseEncryption;
+exports.TeslaFleetMessageFaultResponseSizeExceedsMTU = TeslaFleetMessageFaultResponseSizeExceedsMTU;
+exports.TeslaFleetMessageFaultTimeExpired = TeslaFleetMessageFaultTimeExpired;
+exports.TeslaFleetMessageFaultTimeToLiveTooLong = TeslaFleetMessageFaultTimeToLiveTooLong;
+exports.TeslaFleetMessageFaultTimeout = TeslaFleetMessageFaultTimeout;
+exports.TeslaFleetMessageFaultUnknownKeyId = TeslaFleetMessageFaultUnknownKeyId;
+exports.TeslaFleetMessageFaultWrongPersonalization = TeslaFleetMessageFaultWrongPersonalization;
+exports.TeslemetryRegistrationError = TeslemetryRegistrationError;
+exports.TimeExpiredFault = TimeExpiredFault;
+exports.TokenAndCounterInvalidFault = TokenAndCounterInvalidFault;
+exports.TokenIsIncorrectLengthFault = TokenIsIncorrectLengthFault;
+exports.UnauthorizedClient = UnauthorizedClient;
+exports.UnknownFault = UnknownFault;
+exports.UnsupportedVehicle = UnsupportedVehicle;
+exports.VehicleOffline = VehicleOffline;
+exports.VehicleSubscriptionRequired = VehicleSubscriptionRequired;
+exports.WHITELIST_OPERATION_STATUS = WHITELIST_OPERATION_STATUS;
+exports.WhitelistOperationAttemptingToAddExistingKey = WhitelistOperationAttemptingToAddExistingKey;
+exports.WhitelistOperationAttemptingToAddKeyWithServiceRole = WhitelistOperationAttemptingToAddKeyWithServiceRole;
+exports.WhitelistOperationAttemptingToAddKeyWithoutRole = WhitelistOperationAttemptingToAddKeyWithoutRole;
+exports.WhitelistOperationAttemptingToDemoteSuperiorToOneself = WhitelistOperationAttemptingToDemoteSuperiorToOneself;
+exports.WhitelistOperationAttemptingToElevateOthersAboveOneself = WhitelistOperationAttemptingToElevateOthersAboveOneself;
+exports.WhitelistOperationAttemptingToRemoveOwnPermissions = WhitelistOperationAttemptingToRemoveOwnPermissions;
+exports.WhitelistOperationCouldNotStartLocalEntityAuth = WhitelistOperationCouldNotStartLocalEntityAuth;
+exports.WhitelistOperationFMAttemptingToAddPermanentKey = WhitelistOperationFMAttemptingToAddPermanentKey;
+exports.WhitelistOperationFMAttemptingToRemovePermanentKey = WhitelistOperationFMAttemptingToRemovePermanentKey;
+exports.WhitelistOperationFMModifyingOutsideOfFMode = WhitelistOperationFMModifyingOutsideOfFMode;
+exports.WhitelistOperationInvalidPublicKey = WhitelistOperationInvalidPublicKey;
+exports.WhitelistOperationKeychainWhileFSFull = WhitelistOperationKeychainWhileFSFull;
+exports.WhitelistOperationKeyfobSlotsFull = WhitelistOperationKeyfobSlotsFull;
+exports.WhitelistOperationLocalEntityAuthFailedCancelled = WhitelistOperationLocalEntityAuthFailedCancelled;
+exports.WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForTap = WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForTap;
+exports.WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForUIAck = WhitelistOperationLocalEntityAuthFailedTimedOutWaitingForUIAck;
+exports.WhitelistOperationLocalEntityAuthFailedUIDenied = WhitelistOperationLocalEntityAuthFailedUIDenied;
+exports.WhitelistOperationLocalEntityAuthFailedValetMode = WhitelistOperationLocalEntityAuthFailedValetMode;
+exports.WhitelistOperationNoPermissionToAdd = WhitelistOperationNoPermissionToAdd;
+exports.WhitelistOperationNoPermissionToChangePermissions = WhitelistOperationNoPermissionToChangePermissions;
+exports.WhitelistOperationNoPermissionToRemove = WhitelistOperationNoPermissionToRemove;
+exports.WhitelistOperationNoPermissionToRemoveOneself = WhitelistOperationNoPermissionToRemoveOneself;
+exports.WhitelistOperationNonServiceKeyAttemptingToAddServiceTech = WhitelistOperationNonServiceKeyAttemptingToAddServiceTech;
+exports.WhitelistOperationNotAllowedToAddUnlessOnReader = WhitelistOperationNotAllowedToAddUnlessOnReader;
+exports.WhitelistOperationPublicKeyNotOnWhitelist = WhitelistOperationPublicKeyNotOnWhitelist;
+exports.WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode = WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode;
+exports.WhitelistOperationStatus = WhitelistOperationStatus;
+exports.WhitelistOperationUndocumentedError = WhitelistOperationUndocumentedError;
+exports.WhitelistOperationWhitelistFull = WhitelistOperationWhitelistFull;
+exports.is_key_rejected = is_key_rejected;
+exports.raise_for_status = raise_for_status;