@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/types/vehicle/index.d.cts

@@ -0,0 +1,798 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from '../text-candidate-qg2bD9PY.cjs';
+import { o as SwedishVehicleRegistrationNumber, m as SwedishEcoVehicleClassification } from '../wheel-rim-dimension-CdkDrzad.cjs';
+export { B as BoltPattern, a as BoltPatternFormatOptions, E as EmissionRate, b as EmissionRateFormatOptions, c as EnginePower, d as EnginePowerFormatOptions, e as EuTypeApprovalNumber, f as EuTypeApprovalNumberFormatOptions, g as EuroEmissionClass, h as EuroEmissionClassFormatOptions, F as FuelConsumption, i as FuelConsumptionFormatOptions, O as OperatingHours, j as OperatingHoursFormatOptions, S as SwedishDrivingLicenseCategory, k as SwedishDrivingLicenseCategoryFormatOptions, l as SwedishDrivingLicenseVehicleGroup, n as SwedishEcoVehicleClassificationFormatOptions, p as SwedishVehicleRegistrationNumberFormatOptions, T as TireDimension, q as TireDimensionFormatOptions, V as VehicleIdentificationNumber, r as VehicleIdentificationNumberFormatOptions, W as WheelRimDimension, s as WheelRimDimensionFormatOptions, t as maskBoltPattern, u as maskEmissionRate, v as maskEnginePower, w as maskEuTypeApprovalNumber, x as maskFuelConsumption, y as maskOperatingHours, z as maskSwedishVehicleRegistrationNumber, A as maskTireDimension, C as maskVehicleIdentificationNumber, D as maskWheelRimDimension } from '../wheel-rim-dimension-CdkDrzad.cjs';
+import { D as Decimal, L as Length, b as LengthUnit } from '../length-XRL5Eg7F.cjs';
+import { V as Volume, d as VolumeUnit } from '../volume-CFA4e3dc.cjs';
+import '../validation/index.cjs';
+
+/** Options shared by the string-in, string-out helpers. */
+interface BoatCeDesignCategoryFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * CE design category for recreational craft (`CE-konstruktionskategori`) per the EU
+ * Recreational Craft Directive (RCD) 2013/53/EU and ISO 12217: `A` Ocean, `B` Offshore, `C`
+ * Inshore, `D` Sheltered waters.
+ */
+declare class BoatCeDesignCategory {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly maxSignificantWaveHeightM: number;
+    readonly maxBeaufortWindForce: number;
+    readonly englishDescription: string;
+    readonly localizedDescription: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly A: BoatCeDesignCategory;
+    static readonly B: BoatCeDesignCategory;
+    static readonly C: BoatCeDesignCategory;
+    static readonly D: BoatCeDesignCategory;
+    /** All 4 values, in canonical order. */
+    static get all(): readonly BoatCeDesignCategory[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): BoatCeDesignCategory | null;
+    static parse(input: string): BoatCeDesignCategory;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: BoatCeDesignCategoryFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: BoatCeDesignCategoryFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: BoatCeDesignCategory | null | undefined): boolean;
+    compareTo(other: BoatCeDesignCategory | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface BoatHullMaterialFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * The material used for a boat's hull (`skrovmaterial`), e.g. `Glasfiber`, `Aluminium`,
+ * `Stål`.
+ */
+declare class BoatHullMaterial {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Fiberglass: BoatHullMaterial;
+    static readonly Aluminum: BoatHullMaterial;
+    static readonly Steel: BoatHullMaterial;
+    static readonly Wood: BoatHullMaterial;
+    static readonly Plastic: BoatHullMaterial;
+    static readonly CarbonFiber: BoatHullMaterial;
+    static readonly Inflatable: BoatHullMaterial;
+    static readonly Ferrocement: BoatHullMaterial;
+    static readonly Composite: BoatHullMaterial;
+    /** All 9 values, in canonical order. */
+    static get all(): readonly BoatHullMaterial[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): BoatHullMaterial | null;
+    static parse(input: string): BoatHullMaterial;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: BoatHullMaterialFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: BoatHullMaterialFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: BoatHullMaterial | null | undefined): boolean;
+    compareTo(other: BoatHullMaterial | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface BodyTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A passenger or commercial vehicle body type (`karosstyp`), e.g. `Sedan`, `Hatchback`,
+ * `Stationwagon`, `SUV`, `Pickup`, `Truck`, `LightTruck`, `Trailer`, `Motorhome`, `Tractor`,
+ * `Dumper`, `Tipper`, `OffRoad`.
+ */
+declare class BodyType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Sedan: BodyType;
+    static readonly Hatchback: BodyType;
+    static readonly Stationwagon: BodyType;
+    static readonly Suv: BodyType;
+    static readonly Crossover: BodyType;
+    static readonly Coupe: BodyType;
+    static readonly Convertible: BodyType;
+    static readonly Roadster: BodyType;
+    static readonly Mpv: BodyType;
+    static readonly Minivan: BodyType;
+    static readonly Van: BodyType;
+    static readonly Pickup: BodyType;
+    static readonly Truck: BodyType;
+    static readonly LightTruck: BodyType;
+    static readonly Bus: BodyType;
+    static readonly Microcar: BodyType;
+    static readonly Limousine: BodyType;
+    static readonly Targa: BodyType;
+    static readonly Trailer: BodyType;
+    static readonly Motorhome: BodyType;
+    static readonly Tractor: BodyType;
+    static readonly Tipper: BodyType;
+    static readonly Dumper: BodyType;
+    static readonly OffRoad: BodyType;
+    /** All 24 values, in canonical order. */
+    static get all(): readonly BodyType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): BodyType | null;
+    static parse(input: string): BodyType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: BodyTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: BodyTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: BodyType | null | undefined): boolean;
+    compareTo(other: BodyType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface DrivetrainTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Drivetrain layout (`drivning`) of a road vehicle, e.g. `AWD` (all-wheel drive,
+ * `fyrhjulsdrift`), `FWD` (front-wheel drive, `framhjulsdrift`), or `RWD` (rear-wheel drive,
+ * `bakhjulsdrift`).
+ */
+declare class DrivetrainType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly drivenAxleCount: number;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Awd: DrivetrainType;
+    static readonly Fwd: DrivetrainType;
+    static readonly Rwd: DrivetrainType;
+    /** All 3 values, in canonical order. */
+    static get all(): readonly DrivetrainType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): DrivetrainType | null;
+    static parse(input: string): DrivetrainType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: DrivetrainTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: DrivetrainTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: DrivetrainType | null | undefined): boolean;
+    compareTo(other: DrivetrainType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface FuelConsumptionNormFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A regulatory test cycle / norm under which fuel consumption (and CO₂) is measured for
+ * vehicles (`förbrukningsnorm`), e.g. `NEDC`, `WLTP`, `EPA`.
+ */
+declare class FuelConsumptionNorm {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly region: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Nedc: FuelConsumptionNorm;
+    static readonly Wltp: FuelConsumptionNorm;
+    static readonly Wltc: FuelConsumptionNorm;
+    static readonly Epa: FuelConsumptionNorm;
+    static readonly Jc08: FuelConsumptionNorm;
+    static readonly Cltc: FuelConsumptionNorm;
+    static readonly Unknown: FuelConsumptionNorm;
+    /** All 7 values, in canonical order. */
+    static get all(): readonly FuelConsumptionNorm[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): FuelConsumptionNorm | null;
+    static parse(input: string): FuelConsumptionNorm;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: FuelConsumptionNormFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: FuelConsumptionNormFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: FuelConsumptionNorm | null | undefined): boolean;
+    compareTo(other: FuelConsumptionNorm | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface FuelTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A vehicle fuel or energy type (`drivmedel`) with canonical English identifier, Swedish
+ * display name, and Transportstyrelsen code.
+ */
+declare class FuelType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    readonly code: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Petrol: FuelType;
+    static readonly Diesel: FuelType;
+    static readonly Electric: FuelType;
+    static readonly Ethanol: FuelType;
+    static readonly NaturalGas: FuelType;
+    static readonly Lpg: FuelType;
+    static readonly Hybrid: FuelType;
+    static readonly MildHybrid: FuelType;
+    static readonly PlugInHybrid: FuelType;
+    static readonly Hydrogen: FuelType;
+    static readonly Biodiesel: FuelType;
+    static readonly Methane: FuelType;
+    static readonly Methanol: FuelType;
+    static readonly Hvo: FuelType;
+    static readonly Kerosene: FuelType;
+    static readonly Other: FuelType;
+    /** All 16 values, in canonical order. */
+    static get all(): readonly FuelType[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): FuelType | null;
+    static parse(input: string): FuelType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: FuelTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: FuelTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: FuelType | null | undefined): boolean;
+    compareTo(other: FuelType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface SuspensionTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A vehicle suspension/damping technology (`fjädring`), e.g. `Coil spring`, `Leaf spring`,
+ * `Air`, `Hydropneumatic`, `Torsion bar`.
+ */
+declare class SuspensionType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly CoilSpring: SuspensionType;
+    static readonly LeafSpring: SuspensionType;
+    static readonly Air: SuspensionType;
+    static readonly AirAir: SuspensionType;
+    static readonly AirLeaf: SuspensionType;
+    static readonly LeafLeaf: SuspensionType;
+    static readonly Parabolic: SuspensionType;
+    static readonly AirFront: SuspensionType;
+    static readonly AirRear: SuspensionType;
+    static readonly Hydropneumatic: SuspensionType;
+    static readonly TorsionBar: SuspensionType;
+    static readonly Adaptive: SuspensionType;
+    static readonly MagneticRide: SuspensionType;
+    static readonly Independent: SuspensionType;
+    static readonly MacPherson: SuspensionType;
+    static readonly DoubleWishbone: SuspensionType;
+    static readonly MultiLink: SuspensionType;
+    static readonly SolidAxle: SuspensionType;
+    static readonly Rigid: SuspensionType;
+    /** All 19 values, in canonical order. */
+    static get all(): readonly SuspensionType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): SuspensionType | null;
+    static parse(input: string): SuspensionType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: SuspensionTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: SuspensionTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: SuspensionType | null | undefined): boolean;
+    compareTo(other: SuspensionType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface SwedishVehicleStatusFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/** Swedish vehicle registration status (`fordonsstatus`) from Transportstyrelsen. */
+declare class SwedishVehicleStatus {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly code: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    private constructor();
+    static readonly InService: SwedishVehicleStatus;
+    static readonly Deregistered: SwedishVehicleStatus;
+    static readonly Unregistered: SwedishVehicleStatus;
+    static readonly Stolen: SwedishVehicleStatus;
+    static readonly Exported: SwedishVehicleStatus;
+    static readonly Scrapped: SwedishVehicleStatus;
+    static readonly ReportedStolen: SwedishVehicleStatus;
+    /** All 7 values, in canonical order. */
+    static get all(): readonly SwedishVehicleStatus[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): SwedishVehicleStatus | null;
+    static parse(input: string): SwedishVehicleStatus;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: SwedishVehicleStatusFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: SwedishVehicleStatusFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: SwedishVehicleStatus | null | undefined): boolean;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface SwedishVehicleTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/** Swedish vehicle type classification (`fordonsslag`) as used by Transportstyrelsen. */
+declare class SwedishVehicleType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly code: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    private constructor();
+    static readonly PassengerCar: SwedishVehicleType;
+    static readonly Truck: SwedishVehicleType;
+    static readonly Bus: SwedishVehicleType;
+    static readonly Motorcycle: SwedishVehicleType;
+    static readonly MopedClassI: SwedishVehicleType;
+    static readonly MopedClassII: SwedishVehicleType;
+    static readonly Trailer: SwedishVehicleType;
+    static readonly SemiTrailer: SwedishVehicleType;
+    static readonly Caravan: SwedishVehicleType;
+    static readonly Motorhome: SwedishVehicleType;
+    static readonly AllTerrainVehicle: SwedishVehicleType;
+    static readonly Snowmobile: SwedishVehicleType;
+    static readonly Atv: SwedishVehicleType;
+    static readonly ATractor: SwedishVehicleType;
+    static readonly PowerVehicleI: SwedishVehicleType;
+    static readonly PowerVehicleII: SwedishVehicleType;
+    static readonly LightTruck: SwedishVehicleType;
+    /** All 17 values, in canonical order. */
+    static get all(): readonly SwedishVehicleType[];
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): SwedishVehicleType | null;
+    static parse(input: string): SwedishVehicleType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: SwedishVehicleTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: SwedishVehicleTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: SwedishVehicleType | null | undefined): boolean;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface TireTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * A tire season/intended-use category (`däcktyp`), e.g. `Summer`, `Winter (studded)`, `Winter
+ * (friction)`, `All-season`.
+ */
+declare class TireType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Summer: TireType;
+    static readonly WinterStudded: TireType;
+    static readonly WinterFriction: TireType;
+    static readonly AllSeason: TireType;
+    static readonly AllTerrain: TireType;
+    static readonly MudTerrain: TireType;
+    static readonly Track: TireType;
+    static readonly Industrial: TireType;
+    static readonly Agricultural: TireType;
+    static readonly Spare: TireType;
+    /** All 10 values, in canonical order. */
+    static get all(): readonly TireType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): TireType | null;
+    static parse(input: string): TireType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: TireTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: TireTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: TireType | null | undefined): boolean;
+    compareTo(other: TireType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface TrackTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * The track (continuous tread) material/construction used on tracked vehicles (`bandtyp`) such
+ * as excavators, dumpers, snow groomers, and military vehicles, e.g. `Steel`, `Rubber`,
+ * `Polyurethane`, `Half-track`.
+ */
+declare class TrackType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Steel: TrackType;
+    static readonly Rubber: TrackType;
+    static readonly Polyurethane: TrackType;
+    static readonly RubberPad: TrackType;
+    static readonly HalfTrack: TrackType;
+    static readonly Composite: TrackType;
+    /** All 6 values, in canonical order. */
+    static get all(): readonly TrackType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): TrackType | null;
+    static parse(input: string): TrackType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: TrackTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: TrackTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: TrackType | null | undefined): boolean;
+    compareTo(other: TrackType | null | undefined): number;
+}
+
+/** Options shared by the string-in, string-out helpers. */
+interface TransmissionTypeFormatOptions {
+    /** Return the trimmed original input instead of `null` when the input is invalid. */
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/** A vehicle transmission/gearbox type (`växellåda`). */
+declare class TransmissionType {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly englishName: string;
+    readonly localizedName: string;
+    /** @internal Position in the canonical .NET ordering, used by {@link compareTo}. */
+    private readonly rank;
+    private constructor();
+    static readonly Manual: TransmissionType;
+    static readonly Automatic: TransmissionType;
+    static readonly Cvt: TransmissionType;
+    static readonly DualClutch: TransmissionType;
+    static readonly Sequential: TransmissionType;
+    static readonly SemiAutomatic: TransmissionType;
+    static readonly Amt: TransmissionType;
+    /** All 7 values, in canonical order. */
+    static get all(): readonly TransmissionType[];
+    /** Name in the language selected by {@link PrimitivesDefaults.uiCulture}. */
+    get displayName(): string;
+    /** Resolves a value from its canonical name, localized name, code or any known alias. */
+    static tryParse(input: string | null | undefined): TransmissionType | null;
+    static parse(input: string): TransmissionType;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: TransmissionTypeFormatOptions): string | null;
+    static normalize(input: string | null | undefined, options?: TransmissionTypeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    toDisplayString(): string;
+    toEnglishString(): string;
+    toLocalString(): string;
+    equals(other: TransmissionType | null | undefined): boolean;
+    compareTo(other: TransmissionType | null | undefined): number;
+}
+
+/** Options for {@link EnergyConsumption.format} and {@link EnergyConsumption.normalize}. */
+interface EnergyConsumptionFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * Electric vehicle energy consumption (`elförbrukning`), held as kWh per 100 km.
+ * Accepts `kWh/100km`, `kWh/km`, `Wh/km` and the US `mi/kWh` and `kWh/mi`; a bare
+ * number is read as kWh per 100 km.
+ *
+ * Sources:
+ * - https://en.wikipedia.org/wiki/Fuel_economy_in_electric_vehicles
+ * - https://www.energimyndigheten.se/
+ */
+declare class EnergyConsumption {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Display form preserving the parsed unit, e.g. `150 Wh/km`. */
+    readonly value: string;
+    /** The unit the value was parsed from, e.g. `kWh/100km` or `mi/kWh`. */
+    readonly originalUnit: string;
+    private readonly exactKwhPer100Km;
+    private constructor();
+    /** Consumption in kilowatt-hours per 100 km, e.g. `15` for a typical EV. */
+    get kwhPer100Km(): number;
+    /** Consumption in kilowatt-hours per km, e.g. `0.15` for 15 kWh/100km. */
+    get kwhPerKm(): number;
+    /** Consumption in watt-hours per km, e.g. `150` for 15 kWh/100km. */
+    get whPerKm(): number;
+    /** Energy economy in US miles per kilowatt-hour, e.g. `4.13` for 15 kWh/100km. */
+    get milesPerKwh(): number;
+    /** Consumption in kilowatt-hours per mile, e.g. `0.241` for 15 kWh/100km. */
+    get kwhPerMile(): number;
+    static fromKwhPer100Km(value: number | Decimal): EnergyConsumption;
+    static fromWhPerKm(value: number | Decimal): EnergyConsumption;
+    static fromKwhPerKm(value: number | Decimal): EnergyConsumption;
+    static fromMilesPerKwh(value: number | Decimal): EnergyConsumption;
+    static fromKwhPerMile(value: number | Decimal): EnergyConsumption;
+    private static fromUnit;
+    static tryParse(input: string | null | undefined): EnergyConsumption | null;
+    static parse(input: string): EnergyConsumption;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form in the parsed unit, e.g. `4 mi/kWh`. */
+    static format(input: string | null | undefined, options?: EnergyConsumptionFormatOptions): string | null;
+    /** Returns the value in kWh/100km, e.g. `15 kWh/100km`. */
+    static normalize(input: string | null | undefined, options?: EnergyConsumptionFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Finds energy consumption values in unstructured text, e.g. `150 Wh/km`. */
+    static findCandidatesInText(text: string): readonly TextCandidate<EnergyConsumption>[];
+    /** Returns the value in kWh/100km, e.g. `15 kWh/100km`. */
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: EnergyConsumption | null | undefined): boolean;
+    compareTo(other: EnergyConsumption | null | undefined): number;
+}
+/** Returns a masked energy consumption, e.g. `15 kWh/100km` becomes `*** kWh/100km`. */
+declare function maskEnergyConsumption(consumption: EnergyConsumption): string;
+
+/** Options for {@link EngineDisplacement.format} and {@link EngineDisplacement.normalize}. */
+interface EngineDisplacementFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: VolumeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * Engine displacement (`motorvolym` / `slagvolym`), e.g. `1998 mL` or `2.0 L`.
+ * A bare number is read as cubic centimetres, which are the same as millilitres.
+ */
+declare class EngineDisplacement {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying volume. */
+    readonly displacement: Volume;
+    /** Display form preserving the parsed unit, e.g. `1998 mL`. */
+    readonly value: string;
+    private constructor();
+    /** Displacement in cubic centimetres (cc), which are millilitres. */
+    get cubicCentimeters(): number;
+    /** Displacement in litres. */
+    get liters(): number;
+    /** Creates a displacement from a value and volume unit. The value must be positive. */
+    static create(value: number | Decimal, unit: VolumeUnit): EngineDisplacement;
+    static fromCubicCentimeters(value: number | Decimal): EngineDisplacement;
+    static fromLiters(value: number | Decimal): EngineDisplacement;
+    static tryParse(input: string | null | undefined): EngineDisplacement | null;
+    static parse(input: string): EngineDisplacement;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `1998 mL`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: EngineDisplacementFormatOptions): string | null;
+    /** Returns the value in litres, e.g. `1.998 L`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: EngineDisplacementFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable metric unit, e.g. `2 L` rather than `2000 mL`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: EngineDisplacement): EngineDisplacement;
+    minus(other: EngineDisplacement): EngineDisplacement;
+    times(factor: number | Decimal): EngineDisplacement;
+    dividedBy(divisor: number | Decimal): EngineDisplacement;
+    negated(): EngineDisplacement;
+    equals(other: EngineDisplacement | null | undefined): boolean;
+    compareTo(other: EngineDisplacement | null | undefined): number;
+}
+
+/** Options for {@link OdometerReading.format} and {@link OdometerReading.normalize}. */
+interface OdometerReadingFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: LengthUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A vehicle odometer reading (`mätarställning`), e.g. `15000 km`. A bare number is
+ * read as kilometres. Swedish miles (`mil`, where 1 mil is 10 km) and English
+ * miles (`mi`) are both accepted.
+ */
+declare class OdometerReading {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** The underlying distance. */
+    readonly distance: Length;
+    /** Display form preserving the parsed unit, e.g. `15000 km`. */
+    readonly value: string;
+    private constructor();
+    get kilometers(): number;
+    get miles(): number;
+    /** The reading in Swedish miles, where 1 mil is 10 km. */
+    get swedishMiles(): number;
+    /** Creates a reading from a value and length unit. The value must not be negative. */
+    static create(value: number | Decimal, unit: LengthUnit): OdometerReading;
+    static fromKilometers(value: number | Decimal): OdometerReading;
+    /** Creates a reading from Swedish miles, where 1 mil is 10 km. */
+    static fromSwedishMiles(value: number | Decimal): OdometerReading;
+    static fromMiles(value: number | Decimal): OdometerReading;
+    static fromMeters(value: number | Decimal): OdometerReading;
+    static tryParse(input: string | null | undefined): OdometerReading | null;
+    static parse(input: string): OdometerReading;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the display form, e.g. `15000 km`. Returns `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: OdometerReadingFormatOptions): string | null;
+    /** Returns the value in kilometres, e.g. `15000 km`. Returns `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: OdometerReadingFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Returns the reading in kilometres, e.g. `15000 km`. */
+    toNormalizedString(): string;
+    toString(): string;
+    /** Returns the value in the most readable unit, e.g. `1.5 km` rather than `1500 m`. */
+    toNaturalString(decimals?: number): string;
+    plus(other: OdometerReading): OdometerReading;
+    minus(other: OdometerReading): OdometerReading;
+    times(factor: number | Decimal): OdometerReading;
+    dividedBy(divisor: number | Decimal): OdometerReading;
+    negated(): OdometerReading;
+    equals(other: OdometerReading | null | undefined): boolean;
+    compareTo(other: OdometerReading | null | undefined): number;
+}
+
+/** Options for {@link EuVehicleCategory.format} and {@link EuVehicleCategory.normalize}. */
+interface EuVehicleCategoryFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+}
+/**
+ * An EU vehicle category code (`fordonskategori`) per Regulation (EU) 2018/858 and
+ * Directive 2007/46/EC, e.g. `M1`, `N1G` or `L3e-A2`.
+ *
+ * Sources:
+ * - https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32018R0858
+ * - https://www.transportstyrelsen.se/
+ */
+declare class EuVehicleCategory {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    /** Canonical category code, e.g. `N1`, `M1G` or `L3e-A2`. */
+    readonly value: string;
+    /** Base category letter, e.g. `M`, `N` or `L`. */
+    readonly baseCategory: string;
+    /** Numeric part of the category, e.g. `1`. */
+    readonly categoryNumber: number;
+    /** Optional suffix such as `G` (off-road), `e` (L categories) or `e-A2`. */
+    readonly suffix: string | null;
+    /** English description, e.g. `Passenger vehicle ≤8+1 seats`. */
+    readonly englishDescription: string;
+    /** Swedish description, e.g. `Personbil ≤8+1 passagerare`. */
+    readonly localizedDescription: string;
+    /** `true` when the `G` suffix marks an off-road variant. */
+    readonly isOffRoad: boolean;
+    private constructor();
+    /** The description in the configured display language. */
+    get description(): string;
+    static tryParse(input: string | null | undefined): EuVehicleCategory | null;
+    static parse(input: string): EuVehicleCategory;
+    static isValid(input: string | null | undefined): boolean;
+    /** Returns the description, e.g. `Passenger vehicle ≤8+1 seats`. */
+    static format(input: string | null | undefined, options?: EuVehicleCategoryFormatOptions): string | null;
+    /** Returns the canonical category code, e.g. `M1`. */
+    static normalize(input: string | null | undefined, options?: EuVehicleCategoryFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    /** Returns the canonical category code, e.g. `M1`. */
+    toNormalizedString(): string;
+    /** Returns the canonical category code, e.g. `M1`. */
+    toString(): string;
+    equals(other: EuVehicleCategory | null | undefined): boolean;
+    compareTo(other: EuVehicleCategory | null | undefined): number;
+}
+
+/** Returns the Biluppgifter.se lookup URL as a string. */
+declare function toBiluppgifterUrl(registration: SwedishVehicleRegistrationNumber): string;
+/** Returns the Biluppgifter.se vehicle-information URL. */
+declare function getBiluppgifterUrl(registration: SwedishVehicleRegistrationNumber): URL;
+/** Returns the Car.info vehicle-information URL. */
+declare function getCarInfoUrl(registration: SwedishVehicleRegistrationNumber): URL;
+
+/** Mask a boat CE design category, e.g. `A` becomes `*`. */
+declare function maskBoatCeDesignCategory(category: BoatCeDesignCategory): string;
+/** Mask a boat hull material, e.g. `Fiberglass` becomes `**********`. */
+declare function maskBoatHullMaterial(material: BoatHullMaterial): string;
+/** Mask a body type, e.g. `Sedan` becomes `*****`. */
+declare function maskBodyType(bodyType: BodyType): string;
+/** Mask a drivetrain type, e.g. `AWD` becomes `***`. */
+declare function maskDrivetrainType(drivetrain: DrivetrainType): string;
+/** Mask a fuel consumption norm, e.g. `WLTP` becomes `****`. */
+declare function maskFuelConsumptionNorm(norm: FuelConsumptionNorm): string;
+/**
+ * Mask a suspension type, e.g. `Coil spring` becomes `**** ******`. Spaces and
+ * slashes stay visible so the structure remains recognizable.
+ */
+declare function maskSuspensionType(suspension: SuspensionType): string;
+/**
+ * Mask a Swedish eco-vehicle classification, keeping the leading word:
+ * `Miljöbil 2013` becomes `Miljöbil ****`.
+ */
+declare function maskSwedishEcoVehicleClassification(classification: SwedishEcoVehicleClassification): string;
+/**
+ * Mask a tire type, e.g. `Winter (studded)` becomes `****** (*******)`. Spaces,
+ * parentheses and hyphens stay visible.
+ */
+declare function maskTireType(tireType: TireType): string;
+/** Mask a track type, e.g. `Half-track` becomes `****-*****`. Hyphens stay visible. */
+declare function maskTrackType(track: TrackType): string;
+
+export { BoatCeDesignCategory, type BoatCeDesignCategoryFormatOptions, BoatHullMaterial, type BoatHullMaterialFormatOptions, BodyType, type BodyTypeFormatOptions, DrivetrainType, type DrivetrainTypeFormatOptions, EnergyConsumption, type EnergyConsumptionFormatOptions, EngineDisplacement, type EngineDisplacementFormatOptions, EuVehicleCategory, type EuVehicleCategoryFormatOptions, FuelConsumptionNorm, type FuelConsumptionNormFormatOptions, FuelType, type FuelTypeFormatOptions, OdometerReading, type OdometerReadingFormatOptions, SuspensionType, type SuspensionTypeFormatOptions, SwedishEcoVehicleClassification, SwedishVehicleRegistrationNumber, SwedishVehicleStatus, type SwedishVehicleStatusFormatOptions, SwedishVehicleType, type SwedishVehicleTypeFormatOptions, TireType, type TireTypeFormatOptions, TrackType, type TrackTypeFormatOptions, TransmissionType, type TransmissionTypeFormatOptions, getBiluppgifterUrl, getCarInfoUrl, maskBoatCeDesignCategory, maskBoatHullMaterial, maskBodyType, maskDrivetrainType, maskEnergyConsumption, maskFuelConsumptionNorm, maskSuspensionType, maskSwedishEcoVehicleClassification, maskTireType, maskTrackType, toBiluppgifterUrl };