wenmar-open 0.1.0 → 0.3.0

package/dist/client.js

@@ -1,10 +1,9 @@
+import { MAX_BATCH } from "./batch.js";
 import { WenmarOpenError, parseRetryAfter } from "./errors.js";
 /** The hosted API. */
 export const DEFAULT_BASE_URL = "https://open.wenmarpro.com";
 /** How long a request may take before it fails with `timeout`. */
 export const DEFAULT_TIMEOUT_MS = 10_000;
-/** The most VINs the API decodes in one batch. */
-export const MAX_BATCH = 50;
 function queryString(query) {
     const params = new URLSearchParams();
     for (const [name, value] of Object.entries((query ?? {}))) {
@@ -34,10 +33,6 @@ function segment(field, value) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** Whether an item of a batch is the error for its VIN and not a decode. */
-export function isBatchError(item) {
-    return isRecord(item.error);
-}
 /** A client for the Wenmar Open API. It keeps no state between requests. */
 export class WenmarOpen {
     baseUrl;
@@ -67,7 +62,8 @@ export class WenmarOpen {
                 details: { field: "vins", max: MAX_BATCH, received: vins.length },
             });
         }
-        return this.#request("POST", "/v1/vin/batch", { vins }, options);
+        const path = `/v1/vin/batch${queryString({ include: options.include })}`;
+        return this.#request("POST", path, { vins }, options);
     }
     /** Model years, newest first. */
     async years(query = {}, options = {}) {
@@ -101,6 +97,237 @@ export class WenmarOpen {
     async vehicle(id, options = {}) {
         return this.#request("GET", `/v1/vehicles/${segment("id", id)}`, undefined, options);
     }
+    /**
+     * NHTSA's crash test ratings for a model year, by its id such as
+     * `2018_ford_f-150`. NHTSA rates by body style and drive, so `ratings`
+     * often has several entries: each names the vehicle it is for.
+     */
+    async safety(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/safety`, undefined, options);
+    }
+    /**
+     * What owners reported to NHTSA about a model year, as counts by
+     * component. These are owners' reports: not verified, and not a rate.
+     */
+    async complaints(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/complaints`, undefined, options);
+    }
+    /**
+     * One generic trouble code, such as `P0420`, described in this project's
+     * own words. A manufacturer-specific code has no description: the call
+     * fails with `not_found`.
+     */
+    async code(code, options = {}) {
+        return this.#request("GET", `/v1/codes/${segment("code", code)}`, undefined, options);
+    }
+    /** The trouble codes that are described, by code, narrowed by text or system. */
+    async codes(query = {}, options = {}) {
+        return this.#request("GET", `/v1/codes${queryString(query)}`, undefined, options);
+    }
+    /**
+     * A trouble code on one model year: its description, the bulletins of
+     * that model year that name it, and the bulletins and recalls about the
+     * same components. Any code answers, a manufacturer-specific one too.
+     */
+    async vehicleCode(id, code, options = {}) {
+        const path = `/v1/vehicles/${segment("id", id)}/codes/${segment("code", code)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** The repair jobs a labour estimate can be about. A job's id never changes. */
+    async jobs(options = {}) {
+        return this.#request("GET", "/v1/jobs", undefined, options);
+    }
+    /** One repair job: what it covers, and what it typically takes by class of vehicle. */
+    async job(job, options = {}) {
+        return this.#request("GET", `/v1/jobs/${segment("job", job)}`, undefined, options);
+    }
+    /**
+     * Wenmar's labour estimates for a model year, or for one `job` of it:
+     * for each job, the hours of the narrowest scope that has a figure, and
+     * which scope that was. An estimate, not a quote. Credit it as
+     * `attribution` says.
+     */
+    async labor(id, job, options = {}) {
+        const narrowed = job === undefined ? "" : `/${segment("job", job)}`;
+        const path = `/v1/vehicles/${segment("id", id)}/labor${narrowed}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** Labour estimates for the vehicle a VIN decodes to, or for one `job` of it. */
+    async vinLabor(vin, job, options = {}) {
+        const narrowed = job === undefined ? "" : `/${segment("job", job)}`;
+        const path = `/v1/vin/${segment("vin", vin)}/labor${narrowed}${queryString({ year: options.year })}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * The income tax, CPP, CPP2 and EI on one regular pay in Ontario, by
+     * CRA's T4127 formulas, with the net pay, the employer's share and every
+     * factor used. Claims left out are the basic personal amounts (claim
+     * code 1). An estimate: the employer remains liable to CRA; check with
+     * CRA's PDOC at `pdoc_url`. Not available offline.
+     */
+    async payrollDeductions(query, options = {}) {
+        return this.#request("GET", `/v1/payroll/deductions${queryString(query)}`, undefined, options);
+    }
+    /** One make by its id, name or alias, such as `honda`, with the maker's own links. */
+    async make(make, options = {}) {
+        return this.#request("GET", `/v1/makes/${segment("make", make)}`, undefined, options);
+    }
+    /**
+     * Recalls that may apply to a model year, by its id such as
+     * `2018_ford_f-150`. The list is for the year, make and model: it is not
+     * a lookup by VIN, and `lookup` says where one vehicle can be checked.
+     */
+    async recalls(id, query = {}, options = {}) {
+        const path = `/v1/vehicles/${segment("id", id)}/recalls${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Recalls that may apply to the model year a VIN decodes to. The VIN only
+     * names the model year: no public data says a recall applies to one VIN.
+     */
+    async vinRecalls(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/recalls${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** One recall campaign: `source` is `nhtsa` or `tc`. */
+    async recall(source, campaign, options = {}) {
+        const path = `/v1/recalls/${segment("source", source)}/${segment("campaign", campaign)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** Recall campaigns, newest first, narrowed by what is given. */
+    async searchRecalls(query = {}, options = {}) {
+        return this.#request("GET", `/v1/recalls${queryString(query)}`, undefined, options);
+    }
+    /**
+     * Manufacturer communications that list a model year: service bulletins,
+     * service campaigns, warranty extensions and over-the-air updates, one
+     * page, newest first. `counts` says how many there are of each kind.
+     */
+    async bulletins(id, query = {}, options = {}) {
+        const path = `/v1/vehicles/${segment("id", id)}/bulletins${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** Manufacturer communications for the model year a VIN decodes to. */
+    async vinBulletins(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/bulletins${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** One manufacturer communication, by NHTSA's id number. */
+    async bulletin(nhtsaId, options = {}) {
+        const path = `/v1/bulletins/${segment("nhtsa_id", String(nhtsaId))}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** Manufacturer communications, newest first, narrowed by what is given. */
+    async searchBulletins(query = {}, options = {}) {
+        return this.#request("GET", `/v1/bulletins${queryString(query)}`, undefined, options);
+    }
+    /**
+     * Fuel consumption ratings of a model year, from EPA and Natural Resources
+     * Canada. Each rating says how far it was matched in `confidence`, and
+     * names a catalog engine only when the match settled one.
+     */
+    async fuel(id, query = {}, options = {}) {
+        const path = `/v1/vehicles/${segment("id", id)}/fuel${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Fuel consumption ratings for the vehicle a VIN decodes to: narrowed to
+     * its engine when `engine_settled` is `true`, the model year's otherwise.
+     */
+    async vinFuel(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/fuel${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** Specifications of a model year from EPA's files, one entry per rating. */
+    async specs(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/specs`, undefined, options);
+    }
+    /** Specifications for the vehicle a VIN decodes to. */
+    async vinSpecs(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/specs${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Fluids of a model year: the engine oil viscosity grade the maker
+     * certified each engine with, per EPA, and the records a person read from
+     * the maker's own documents, each with its source and the day it was checked.
+     */
+    async fluids(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/fluids`, undefined, options);
+    }
+    /** Fluids for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    async vinFluids(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/fluids${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Original-equipment tire fitments of a model year, read by a person from
+     * the door placard or the owner's manual. Every size on record is listed
+     * with the trims it covers; none is picked.
+     */
+    async tires(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/tires`, undefined, options);
+    }
+    /** Tire fitments of the model year a VIN decodes to. Never narrowed: a VIN does not name the wheels. */
+    async vinTires(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/tires${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * The parts-ordering card for a VIN: what a parts counter asks for, each
+     * line with where it came from. `text` is the card ready to paste.
+     */
+    async partsCard(vin, query = {}, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/parts-card${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Everything held for a model year in one answer, by its id such as
+     * `2018_ford_f-150`. A block the server has no data for is `null`.
+     * `recalls` counts the campaigns that may apply to the year, make and
+     * model: it is not a lookup by VIN.
+     */
+    async overview(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}/overview`, undefined, options);
+    }
+    /**
+     * The overview of the model year a VIN decodes to, with `decode`. The VIN
+     * only names the model year: no public data says a recall applies to one
+     * VIN.
+     */
+    async vinOverview(vin, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}/overview${queryString({ year: options.year })}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Every model year of one model, newest first, each with its vehicle id
+     * and the number of recall campaigns that may apply to it.
+     */
+    async modelYears(make, model, options = {}) {
+        const path = `/v1/models/${segment("make", make)}/${segment("model", model)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Recall campaigns reported on or after `since` (a day such as
+     * `2026-09-01`), newest first, each with the vehicles it may apply to.
+     */
+    async recentRecalls(query, options = {}) {
+        return this.#request("GET", `/v1/recalls/recent${queryString(query)}`, undefined, options);
+    }
+    /**
+     * The open NHTSA investigations that list a model year, by its id such as
+     * `2019_ram_1500`; `{ status: "all" }` adds the closed ones. An
+     * investigation is not a finding that a defect exists: show `note`.
+     */
+    async investigations(id, query = {}, options = {}) {
+        const path = `/v1/vehicles/${segment("id", id)}/investigations${queryString(query)}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /** The NHTSA investigations that led to a recall campaign: `source` is `nhtsa` or `tc`. */
+    async recallInvestigations(source, campaign, options = {}) {
+        const path = `/v1/recalls/${segment("source", source)}/${segment("campaign", campaign)}/investigations`;
+        return this.#request("GET", path, undefined, options);
+    }
     /** The data version, the vPIC release it came from, and the build time. */
     async meta(options = {}) {
         return this.#request("GET", "/v1/meta", undefined, options);

package/dist/errors.d.ts

@@ -1,5 +1,12 @@
-/** The codes the API answers with. */
-export type ApiErrorCode = "invalid_vin" | "validation_failed" | "not_found" | "method_not_allowed" | "payload_too_large" | "uri_too_long" | "rate_limited" | "unavailable" | "internal_error";
+/**
+ * The codes the API answers with.
+ *
+ * `dataset_unavailable` is a `404` from a method that reads a dataset the
+ * server does not hold, such as recalls: `details.dataset` names it, as
+ * `recalls_us` or `recalls_ca`. It is not `not_found`: the vehicle may well
+ * exist, and another server, or the same one later, may hold the data.
+ */
+export type ApiErrorCode = "invalid_vin" | "validation_failed" | "not_found" | "dataset_unavailable" | "method_not_allowed" | "payload_too_large" | "uri_too_long" | "rate_limited" | "unavailable" | "internal_error";
 /**
  * The codes this client adds for failures that never reached the API or
  * did not come from it.
@@ -11,11 +18,22 @@ export type ApiErrorCode = "invalid_vin" | "validation_failed" | "not_found" | "
  *   error page and a sign-in page from a captive portal both end up here.
  */
 export type ClientErrorCode = "network" | "timeout" | "aborted" | "bad_response";
+/**
+ * The codes of `wenmar-open/offline`, for failures of the data and not of
+ * the question. The command-line tool uses `no_data` and `data_invalid` for
+ * the same things.
+ *
+ * - `no_data`: there is no data file where one was looked for.
+ * - `data_invalid`: the database is not a data file this version reads: it
+ *   has another schema version, or a row is not what the layout says.
+ * - `store_error`: the database failed while it was being read.
+ */
+export type OfflineErrorCode = "no_data" | "data_invalid" | "store_error";
 /**
  * Every code known when this version was published. The API may add codes,
  * so `code` is typed to accept any string while still completing these.
  */
-export type ErrorCode = ApiErrorCode | ClientErrorCode | (string & {});
+export type ErrorCode = ApiErrorCode | ClientErrorCode | OfflineErrorCode | (string & {});
 export interface WenmarOpenErrorInit {
     code: ErrorCode;
     message: string;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, MAX_BATCH, WenmarOpen, isBatchError, } from "./client.js";
-export type { ClientOptions, DecodeOptions, FetchInit, FetchLike, FetchResponse, RequestOptions, } from "./client.js";
+export { MAX_BATCH, isBatchError } from "./batch.js";
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, WenmarOpen } from "./client.js";
+export type { BatchOptions, ClientOptions, DecodeOptions, FetchInit, FetchLike, FetchResponse, RequestOptions, } from "./client.js";
 export { WenmarOpenError } from "./errors.js";
-export type { ApiErrorCode, ClientErrorCode, ErrorCode, WenmarOpenErrorInit } from "./errors.js";
-export type { BatchItem, CheckDigit, Engine, EngineOption, EnginesQuery, Entry, ErrorBody, Make, MakesQuery, Manufacturer, Meta, Model, ModelsQuery, Plant, Safety, SearchQuery, Selection, Submodel, SubmodelsQuery, VinDecode, Warning, YearsQuery, } from "./types.js";
+export type { ApiErrorCode, ClientErrorCode, ErrorCode, OfflineErrorCode, WenmarOpenErrorInit, } from "./errors.js";
+export type { BatchItem, Bulletin, BulletinCounts, BulletinDetail, BulletinDocument, BulletinFilterQuery, BulletinList, BulletinSearchQuery, Code, CodeLink, CodeList, CodeSearchQuery, CheckDigit, Engine, EngineOil, FluidRecord, EngineOption, EnginesQuery, Entry, ErrorBody, FuelRating, Investigation, Make, MakeDetail, MakesQuery, Manufacturer, Meta, Model, ModelYears, ModelsQuery, Overview, OverviewBulletins, OverviewRecalls, PayrollDeductions, PayrollDeductionsQuery, PayrollFactor, PartsCard, PartsCardLine, Plant, Recall, RecallCampaign, RecallCompletion, RecallCount, RecallInvestigations, RecallList, RecallLookup, RecallSearchQuery, RecentRecalls, RecentRecallsQuery, Safety, SafetyRating, SearchQuery, Selection, Spec, Submodel, SubmodelsQuery, TireFitment, JobDetail, JobList, LaborFigure, VehicleLabor, VinLabor, VehicleBulletins, VehicleCode, VehicleComplaints, VehicleFluids, VehicleFuel, VehicleFuelQuery, VehicleInvestigations, VehicleInvestigationsQuery, VehicleRecalls, VehicleRecallsQuery, VehicleSafety, VehicleSpecs, VehicleTires, VinBulletins, VinBulletinsQuery, VinDecode, VinFluids, VinFuel, VinFuelQuery, VinRecallCount, VinRecalls, VinRecallsQuery, VinSpecs, VinTires, VinYearQuery, Warning, YearsQuery, } from "./types.js";
 export type { components, operations, paths } from "./schema.js";

package/dist/index.js

@@ -1,2 +1,3 @@
-export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, MAX_BATCH, WenmarOpen, isBatchError, } from "./client.js";
+export { MAX_BATCH, isBatchError } from "./batch.js";
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, WenmarOpen } from "./client.js";
 export { WenmarOpenError } from "./errors.js";

package/dist/offline/client.d.ts

@@ -0,0 +1,190 @@
+import type { DecodeOptions, RequestOptions } from "../client.js";
+import type { BatchItem, EngineOption, EnginesQuery, Entry, Make, MakesQuery, Meta, Model, ModelsQuery, Code, CodeList, CodeSearchQuery, JobDetail, JobList, ModelYears, Overview, RecallCampaign, RecallList, RecallSearchQuery, RecentRecalls, RecentRecallsQuery, SearchQuery, Submodel, SubmodelsQuery, VehicleFluids, VehicleFuel, VehicleComplaints, VehicleFuelQuery, VehicleRecalls, VehicleRecallsQuery, VehicleCode, VehicleLabor, VehicleSafety, VehicleSpecs, VehicleTires, VinDecode, VinLabor, VinFluids, VinFuel, VinFuelQuery, VinRecalls, VinRecallsQuery, VinSpecs, VinTires, VinYearQuery, YearsQuery } from "../types.js";
+import type { WasmSource } from "./engine.js";
+import type { Store } from "./store.js";
+/**
+ * The most times one question, or the opening of the data, may go back to
+ * the store. Opening takes 2; over the fixture of the tests a decode takes
+ * at most 7 and a search at most 4. Reaching this means something is wrong.
+ */
+export declare const MAX_STEPS = 32;
+export interface OfflineOptions {
+    /** Where the data is: `syncStore(...)`, `d1Store(...)`, or your own. */
+    store: Store;
+    /**
+     * Where the shop file is: a second database, which holds the recalls.
+     * It must be the shop file that was built against the data file in
+     * `store`. Leave it out and the recall methods fail with
+     * `dataset_unavailable`; everything else works.
+     */
+    shop?: Store;
+    /**
+     * The decoder. Leave it out everywhere but Cloudflare Workers, where it
+     * is the module `import wasm from "wenmar-open/offline.wasm"` gives.
+     */
+    wasm?: WasmSource;
+    /**
+     * The current calendar year, which bounds the model years a VIN can
+     * have. Default: the year of the device's clock, in UTC.
+     */
+    currentYear?: number;
+}
+/**
+ * VIN decoding and the vehicle catalog with no network: the methods of
+ * `WenmarOpen`, answered from a data file by the decoder inside the package.
+ * Every method gives what the hosted API gives for the same question and
+ * fails with the same `WenmarOpenError` codes.
+ */
+export declare class WenmarOpenOffline {
+    #private;
+    constructor(options: OfflineOptions);
+    /** Decode one VIN. Spaces, dashes and lowercase are accepted. */
+    decodeVin(vin: string, options?: DecodeOptions): Promise<VinDecode>;
+    /**
+     * Decode up to 50 VINs. The answer has one item per VIN, in order: a
+     * decode, or the error a single call for that VIN would have thrown.
+     * Tell them apart with `isBatchError`.
+     */
+    decodeVins(vins: readonly string[], options?: RequestOptions): Promise<BatchItem[]>;
+    /** Model years, newest first. */
+    years(query?: YearsQuery, options?: RequestOptions): Promise<number[]>;
+    /** Makes, popular ones first and the rest by name. */
+    makes(query?: MakesQuery, options?: RequestOptions): Promise<Make[]>;
+    /** Models of a make, by name. An unknown make has no models. */
+    models(query: ModelsQuery, options?: RequestOptions): Promise<Model[]>;
+    /** Submodels of a model year: trims, or series where there are no trims. */
+    submodels(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** The same as `submodels`, under the name most people use. */
+    trims(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** Engines of a model year, in short form. */
+    engines(query: EnginesQuery, options?: RequestOptions): Promise<EngineOption[]>;
+    /**
+     * Catalog entries for free text such as `2019 civic si`, best first. The
+     * hosted API also finds words in any order with an index of its own;
+     * here, text the catalog cannot read as year, make, model and submodel
+     * finds nothing.
+     */
+    search(query: SearchQuery, options?: RequestOptions): Promise<Entry[]>;
+    /** One catalog entry by its id, such as `2019_honda_civic_si`. */
+    vehicle(id: string, options?: RequestOptions): Promise<Entry>;
+    /**
+     * NHTSA's crash test ratings for a model year, by its id such as
+     * `2018_ford_f-150`. NHTSA rates by body style and drive, so `ratings`
+     * often has several entries: each names the vehicle it is for. Needs a
+     * shop file that holds the ratings: without one it fails with
+     * `dataset_unavailable`.
+     */
+    safety(id: string, options?: RequestOptions): Promise<VehicleSafety>;
+    /**
+     * What owners reported to NHTSA about a model year, as counts by component
+     * with the median mileage they gave. Without a shop file that holds the
+     * complaints it fails with `dataset_unavailable`.
+     */
+    complaints(id: string, options?: RequestOptions): Promise<VehicleComplaints>;
+    /**
+     * Fuel consumption ratings of a model year, from EPA and Natural
+     * Resources Canada. Each says in `confidence` how far it was matched:
+     * `model`, `engine` or `submodel`. Needs a shop file that holds them:
+     * without one it fails with `dataset_unavailable`.
+     */
+    fuel(id: string, query?: VehicleFuelQuery, options?: RequestOptions): Promise<VehicleFuel>;
+    /** Fuel ratings for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    vinFuel(vin: string, query?: VinFuelQuery, options?: RequestOptions): Promise<VinFuel>;
+    /** Specifications of a model year from EPA's files, one entry per EPA rating. */
+    specs(id: string, options?: RequestOptions): Promise<VehicleSpecs>;
+    /** Specifications for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    vinSpecs(vin: string, query?: VinYearQuery, options?: RequestOptions): Promise<VinSpecs>;
+    /**
+     * Fluids of a model year: the engine oil viscosity grade the maker
+     * certified each engine with, per EPA, and the records a person read from
+     * the maker's own documents, each with its source and the day it was checked.
+     */
+    fluids(id: string, options?: RequestOptions): Promise<VehicleFluids>;
+    /** Fluids for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    vinFluids(vin: string, query?: VinYearQuery, options?: RequestOptions): Promise<VinFluids>;
+    /**
+     * Original-equipment tire fitments of a model year. Every size on record
+     * is listed with the trims it covers; none is picked.
+     */
+    tires(id: string, options?: RequestOptions): Promise<VehicleTires>;
+    /** Tire fitments of the model year a VIN decodes to. Never narrowed: a VIN does not name the wheels. */
+    vinTires(vin: string, query?: VinYearQuery, options?: RequestOptions): Promise<VinTires>;
+    /** The repair jobs a labour estimate can be about. Needs a shop file that holds the job list. */
+    jobs(options?: RequestOptions): Promise<JobList>;
+    /** One repair job: what it covers, and what it typically takes by class of vehicle. */
+    job(job: string, options?: RequestOptions): Promise<JobDetail>;
+    /**
+     * Wenmar's labour estimates for a model year, or for one `job` of it.
+     * An estimate, not a quote; credit it as `attribution` says. Needs a
+     * shop file that holds the estimates.
+     */
+    labor(id: string, job?: string, options?: RequestOptions): Promise<VehicleLabor>;
+    /** Labour estimates for the vehicle a VIN decodes to, or for one `job` of it. */
+    vinLabor(vin: string, job?: string, options?: RequestOptions & {
+        year?: number;
+    }): Promise<VinLabor>;
+    /**
+     * One generic trouble code, such as `P0420`, described in this project's
+     * own words. Needs a shop file that holds the codes: without one it
+     * fails with `dataset_unavailable`.
+     */
+    code(code: string, options?: RequestOptions): Promise<Code>;
+    /** The trouble codes that are described, by code, narrowed by text or system. */
+    codes(query?: CodeSearchQuery, options?: RequestOptions): Promise<CodeList>;
+    /**
+     * A trouble code on one model year: its description and the recalls
+     * about the same components. `bulletins` and `related.bulletins` are
+     * always `null` offline: bulletins are on the hosted service only.
+     */
+    vehicleCode(id: string, code: string, options?: RequestOptions): Promise<VehicleCode>;
+    /**
+     * Recalls that may apply to a model year, by its id such as
+     * `2018_ford_f-150`. The list is for the year, make and model: it is not
+     * a lookup by VIN, and `lookup` says where one vehicle can be checked.
+     * Needs a shop file: without one it fails with `dataset_unavailable`.
+     */
+    recalls(id: string, query?: VehicleRecallsQuery, options?: RequestOptions): Promise<VehicleRecalls>;
+    /**
+     * Recalls that may apply to the model year a VIN decodes to. The VIN only
+     * names the model year: no public data says a recall applies to one VIN.
+     */
+    vinRecalls(vin: string, query?: VinRecallsQuery, options?: RequestOptions): Promise<VinRecalls>;
+    /** One recall campaign: `source` is `nhtsa` or `tc`. */
+    recall(source: string, campaign: string, options?: RequestOptions): Promise<RecallCampaign>;
+    /** Recall campaigns, newest first, narrowed by what is given. */
+    searchRecalls(query?: RecallSearchQuery, options?: RequestOptions): Promise<RecallList>;
+    /**
+     * Everything held for a model year in one answer, by its id such as
+     * `2018_ford_f-150`. A block the files do not hold is `null`. `recalls`
+     * counts the campaigns that may apply to the year, make and model: it is
+     * not a lookup by VIN. With no shop file `recalls` is `null`, and the
+     * method still answers.
+     */
+    overview(id: string, options?: RequestOptions): Promise<Overview>;
+    /**
+     * The overview of the model year a VIN decodes to, with `decode`. The VIN
+     * only names the model year: no public data says a recall applies to one
+     * VIN.
+     */
+    vinOverview(vin: string, options?: DecodeOptions): Promise<Overview>;
+    /**
+     * Every model year of one model, newest first, each with its vehicle id
+     * and the number of recall campaigns that may apply to it: `null` with no
+     * shop file.
+     */
+    modelYears(make: string, model: string, options?: RequestOptions): Promise<ModelYears>;
+    /**
+     * Recall campaigns reported on or after `since` (a day such as
+     * `2026-09-01`), newest first, each with the vehicles it may apply to.
+     * Needs a shop file: without one it fails with `dataset_unavailable`.
+     */
+    recentRecalls(query: RecentRecallsQuery, options?: RequestOptions): Promise<RecentRecalls>;
+    /**
+     * The data version, the vPIC release it came from, and the build time.
+     * `server_version` is the version of this package. `datasets` lists what
+     * the shop file holds, and is empty when no shop store was given.
+     */
+    meta(options?: RequestOptions): Promise<Meta>;
+    /** Closes the stores, if they were opened for this client. */
+    close(): void;
+}