@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/types/frequency-CweGfJFS.d.cts

@@ -0,0 +1,329 @@
+import { M as MeasurementUnit, c as MeasurementUnitIndex, D as Decimal, Q as Quantity } from './length-XRL5Eg7F.cjs';
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.cjs';
+
+/**
+ * A unit of data size identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class DataSizeUnit extends MeasurementUnit {
+    private readonly __dataSizeUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Byte: DataSizeUnit;
+    static readonly Kilobyte: DataSizeUnit;
+    static readonly Megabyte: DataSizeUnit;
+    static readonly Gigabyte: DataSizeUnit;
+    static readonly Terabyte: DataSizeUnit;
+    static readonly Petabyte: DataSizeUnit;
+    static readonly Exabyte: DataSizeUnit;
+    static readonly Kibibyte: DataSizeUnit;
+    static readonly Mebibyte: DataSizeUnit;
+    static readonly Gibibyte: DataSizeUnit;
+    static readonly Tebibyte: DataSizeUnit;
+    static readonly Pebibyte: DataSizeUnit;
+    static readonly Exbibyte: DataSizeUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<DataSizeUnit>;
+    static get all(): readonly DataSizeUnit[];
+    /** The base unit: B. */
+    static get baseUnit(): DataSizeUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly DataSizeUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): DataSizeUnit | null;
+    static parse(input: string): DataSizeUnit;
+    /** Returns the most human-readable unit for a value in B. */
+    static getNatural(baseValue: Decimal): DataSizeUnit;
+}
+
+/** Options for {@link DataSize.format} and {@link DataSize.normalize}. */
+interface DataSizeFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: DataSizeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A data size stored internally in bytes,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class DataSize extends Quantity<DataSizeUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<DataSizeUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: DataSizeUnit): this;
+    get bytes(): number;
+    get kilobytes(): number;
+    get megabytes(): number;
+    get gigabytes(): number;
+    get terabytes(): number;
+    get petabytes(): number;
+    get exabytes(): number;
+    get kibibytes(): number;
+    get mebibytes(): number;
+    get gibibytes(): number;
+    get tebibytes(): number;
+    get pebibytes(): number;
+    get exbibytes(): number;
+    /** Creates a data size from a value and unit. */
+    static create(value: number | Decimal, unit: DataSizeUnit): DataSize;
+    static fromBytes(value: number | Decimal): DataSize;
+    static fromKilobytes(value: number | Decimal): DataSize;
+    static fromMegabytes(value: number | Decimal): DataSize;
+    static fromGigabytes(value: number | Decimal): DataSize;
+    static fromTerabytes(value: number | Decimal): DataSize;
+    static fromPetabytes(value: number | Decimal): DataSize;
+    static fromExabytes(value: number | Decimal): DataSize;
+    static fromKibibytes(value: number | Decimal): DataSize;
+    static fromMebibytes(value: number | Decimal): DataSize;
+    static fromGibibytes(value: number | Decimal): DataSize;
+    static fromTebibytes(value: number | Decimal): DataSize;
+    static fromPebibytes(value: number | Decimal): DataSize;
+    static fromExbibytes(value: number | Decimal): DataSize;
+    static tryParse(input: string | null | undefined): DataSize | null;
+    static parse(input: string): DataSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: DataSizeFormatOptions): string | null;
+    /** The value in bytes, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: DataSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<DataSize>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked data size, e.g. `10 B` becomes `*** B`. */
+declare function maskDataSize(value: DataSize): string;
+
+/**
+ * A unit of electric charge identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class ElectricChargeUnit extends MeasurementUnit {
+    private readonly __electricChargeUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly MilliampereHour: ElectricChargeUnit;
+    static readonly AmpereHour: ElectricChargeUnit;
+    static readonly Coulomb: ElectricChargeUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<ElectricChargeUnit>;
+    static get all(): readonly ElectricChargeUnit[];
+    /** The base unit: Ah. */
+    static get baseUnit(): ElectricChargeUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly ElectricChargeUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): ElectricChargeUnit | null;
+    static parse(input: string): ElectricChargeUnit;
+    /** Returns the most human-readable unit for a value in Ah. */
+    static getNatural(baseValue: Decimal): ElectricChargeUnit;
+}
+
+/** Options for {@link ElectricCharge.format} and {@link ElectricCharge.normalize}. */
+interface ElectricChargeFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: ElectricChargeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A electric charge stored internally in ampere-hours,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class ElectricCharge extends Quantity<ElectricChargeUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<ElectricChargeUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: ElectricChargeUnit): this;
+    get milliampereHours(): number;
+    get ampereHours(): number;
+    get coulombs(): number;
+    /** Creates a electric charge from a value and unit. */
+    static create(value: number | Decimal, unit: ElectricChargeUnit): ElectricCharge;
+    static fromMilliampereHours(value: number | Decimal): ElectricCharge;
+    static fromAmpereHours(value: number | Decimal): ElectricCharge;
+    static fromCoulombs(value: number | Decimal): ElectricCharge;
+    static tryParse(input: string | null | undefined): ElectricCharge | null;
+    static parse(input: string): ElectricCharge;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: ElectricChargeFormatOptions): string | null;
+    /** The value in ampere-hours, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: ElectricChargeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<ElectricCharge>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked electric charge, e.g. `10 Ah` becomes `*** Ah`. */
+declare function maskElectricCharge(value: ElectricCharge): string;
+
+/**
+ * A unit of energy identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class EnergyUnit extends MeasurementUnit {
+    private readonly __energyUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Joule: EnergyUnit;
+    static readonly Kilojoule: EnergyUnit;
+    static readonly Megajoule: EnergyUnit;
+    static readonly Gigajoule: EnergyUnit;
+    static readonly Terajoule: EnergyUnit;
+    static readonly WattHour: EnergyUnit;
+    static readonly KilowattHour: EnergyUnit;
+    static readonly MegawattHour: EnergyUnit;
+    static readonly GigawattHour: EnergyUnit;
+    static readonly TerawattHour: EnergyUnit;
+    static readonly Calorie: EnergyUnit;
+    static readonly Kilocalorie: EnergyUnit;
+    static readonly Btu: EnergyUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<EnergyUnit>;
+    static get all(): readonly EnergyUnit[];
+    /** The base unit: J. */
+    static get baseUnit(): EnergyUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly EnergyUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): EnergyUnit | null;
+    static parse(input: string): EnergyUnit;
+    /** Returns the most human-readable unit for a value in J. */
+    static getNatural(baseValue: Decimal): EnergyUnit;
+}
+
+/** Options for {@link Energy.format} and {@link Energy.normalize}. */
+interface EnergyFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: EnergyUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A energy stored internally in joules,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Energy extends Quantity<EnergyUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<EnergyUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: EnergyUnit): this;
+    get joules(): number;
+    get kilojoules(): number;
+    get megajoules(): number;
+    get gigajoules(): number;
+    get terajoules(): number;
+    get wattHours(): number;
+    get kilowattHours(): number;
+    get megawattHours(): number;
+    get gigawattHours(): number;
+    get terawattHours(): number;
+    get calories(): number;
+    get kilocalories(): number;
+    get btus(): number;
+    /** Creates a energy from a value and unit. */
+    static create(value: number | Decimal, unit: EnergyUnit): Energy;
+    static fromJoules(value: number | Decimal): Energy;
+    static fromKilojoules(value: number | Decimal): Energy;
+    static fromMegajoules(value: number | Decimal): Energy;
+    static fromGigajoules(value: number | Decimal): Energy;
+    static fromTerajoules(value: number | Decimal): Energy;
+    static fromWattHours(value: number | Decimal): Energy;
+    static fromKilowattHours(value: number | Decimal): Energy;
+    static fromMegawattHours(value: number | Decimal): Energy;
+    static fromGigawattHours(value: number | Decimal): Energy;
+    static fromTerawattHours(value: number | Decimal): Energy;
+    static fromCalories(value: number | Decimal): Energy;
+    static fromKilocalories(value: number | Decimal): Energy;
+    static fromBtus(value: number | Decimal): Energy;
+    static tryParse(input: string | null | undefined): Energy | null;
+    static parse(input: string): Energy;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: EnergyFormatOptions): string | null;
+    /** The value in joules, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: EnergyFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Energy>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked energy, e.g. `10 J` becomes `*** J`. */
+declare function maskEnergy(value: Energy): string;
+
+/**
+ * A unit of frequency identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class FrequencyUnit extends MeasurementUnit {
+    private readonly __frequencyUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Hertz: FrequencyUnit;
+    static readonly Kilohertz: FrequencyUnit;
+    static readonly Megahertz: FrequencyUnit;
+    static readonly Gigahertz: FrequencyUnit;
+    static readonly Terahertz: FrequencyUnit;
+    static readonly RevolutionsPerMinute: FrequencyUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<FrequencyUnit>;
+    static get all(): readonly FrequencyUnit[];
+    /** The base unit: Hz. */
+    static get baseUnit(): FrequencyUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly FrequencyUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): FrequencyUnit | null;
+    static parse(input: string): FrequencyUnit;
+    /** Returns the most human-readable unit for a value in Hz. */
+    static getNatural(baseValue: Decimal): FrequencyUnit;
+}
+
+/** Options for {@link Frequency.format} and {@link Frequency.normalize}. */
+interface FrequencyFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: FrequencyUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A frequency stored internally in hertz,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Frequency extends Quantity<FrequencyUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<FrequencyUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: FrequencyUnit): this;
+    get hertz(): number;
+    get kilohertz(): number;
+    get megahertz(): number;
+    get gigahertz(): number;
+    get terahertz(): number;
+    get rpm(): number;
+    /** Creates a frequency from a value and unit. */
+    static create(value: number | Decimal, unit: FrequencyUnit): Frequency;
+    static fromHertz(value: number | Decimal): Frequency;
+    static fromKilohertz(value: number | Decimal): Frequency;
+    static fromMegahertz(value: number | Decimal): Frequency;
+    static fromGigahertz(value: number | Decimal): Frequency;
+    static fromTerahertz(value: number | Decimal): Frequency;
+    static fromRpm(value: number | Decimal): Frequency;
+    static tryParse(input: string | null | undefined): Frequency | null;
+    static parse(input: string): Frequency;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: FrequencyFormatOptions): string | null;
+    /** The value in hertz, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: FrequencyFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Frequency>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked frequency, e.g. `10 Hz` becomes `*** Hz`. */
+declare function maskFrequency(value: Frequency): string;
+
+export { DataSize as D, ElectricCharge as E, Frequency as F, type DataSizeFormatOptions as a, DataSizeUnit as b, type ElectricChargeFormatOptions as c, ElectricChargeUnit as d, Energy as e, type EnergyFormatOptions as f, EnergyUnit as g, type FrequencyFormatOptions as h, FrequencyUnit as i, maskElectricCharge as j, maskEnergy as k, maskFrequency as l, maskDataSize as m };

package/dist/types/frequency-DdOMV6Sw.d.ts

@@ -0,0 +1,329 @@
+import { M as MeasurementUnit, c as MeasurementUnitIndex, D as Decimal, Q as Quantity } from './length-CceXIJYY.js';
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.js';
+
+/**
+ * A unit of data size identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class DataSizeUnit extends MeasurementUnit {
+    private readonly __dataSizeUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Byte: DataSizeUnit;
+    static readonly Kilobyte: DataSizeUnit;
+    static readonly Megabyte: DataSizeUnit;
+    static readonly Gigabyte: DataSizeUnit;
+    static readonly Terabyte: DataSizeUnit;
+    static readonly Petabyte: DataSizeUnit;
+    static readonly Exabyte: DataSizeUnit;
+    static readonly Kibibyte: DataSizeUnit;
+    static readonly Mebibyte: DataSizeUnit;
+    static readonly Gibibyte: DataSizeUnit;
+    static readonly Tebibyte: DataSizeUnit;
+    static readonly Pebibyte: DataSizeUnit;
+    static readonly Exbibyte: DataSizeUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<DataSizeUnit>;
+    static get all(): readonly DataSizeUnit[];
+    /** The base unit: B. */
+    static get baseUnit(): DataSizeUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly DataSizeUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): DataSizeUnit | null;
+    static parse(input: string): DataSizeUnit;
+    /** Returns the most human-readable unit for a value in B. */
+    static getNatural(baseValue: Decimal): DataSizeUnit;
+}
+
+/** Options for {@link DataSize.format} and {@link DataSize.normalize}. */
+interface DataSizeFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: DataSizeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A data size stored internally in bytes,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class DataSize extends Quantity<DataSizeUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<DataSizeUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: DataSizeUnit): this;
+    get bytes(): number;
+    get kilobytes(): number;
+    get megabytes(): number;
+    get gigabytes(): number;
+    get terabytes(): number;
+    get petabytes(): number;
+    get exabytes(): number;
+    get kibibytes(): number;
+    get mebibytes(): number;
+    get gibibytes(): number;
+    get tebibytes(): number;
+    get pebibytes(): number;
+    get exbibytes(): number;
+    /** Creates a data size from a value and unit. */
+    static create(value: number | Decimal, unit: DataSizeUnit): DataSize;
+    static fromBytes(value: number | Decimal): DataSize;
+    static fromKilobytes(value: number | Decimal): DataSize;
+    static fromMegabytes(value: number | Decimal): DataSize;
+    static fromGigabytes(value: number | Decimal): DataSize;
+    static fromTerabytes(value: number | Decimal): DataSize;
+    static fromPetabytes(value: number | Decimal): DataSize;
+    static fromExabytes(value: number | Decimal): DataSize;
+    static fromKibibytes(value: number | Decimal): DataSize;
+    static fromMebibytes(value: number | Decimal): DataSize;
+    static fromGibibytes(value: number | Decimal): DataSize;
+    static fromTebibytes(value: number | Decimal): DataSize;
+    static fromPebibytes(value: number | Decimal): DataSize;
+    static fromExbibytes(value: number | Decimal): DataSize;
+    static tryParse(input: string | null | undefined): DataSize | null;
+    static parse(input: string): DataSize;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: DataSizeFormatOptions): string | null;
+    /** The value in bytes, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: DataSizeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<DataSize>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked data size, e.g. `10 B` becomes `*** B`. */
+declare function maskDataSize(value: DataSize): string;
+
+/**
+ * A unit of electric charge identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class ElectricChargeUnit extends MeasurementUnit {
+    private readonly __electricChargeUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly MilliampereHour: ElectricChargeUnit;
+    static readonly AmpereHour: ElectricChargeUnit;
+    static readonly Coulomb: ElectricChargeUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<ElectricChargeUnit>;
+    static get all(): readonly ElectricChargeUnit[];
+    /** The base unit: Ah. */
+    static get baseUnit(): ElectricChargeUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly ElectricChargeUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): ElectricChargeUnit | null;
+    static parse(input: string): ElectricChargeUnit;
+    /** Returns the most human-readable unit for a value in Ah. */
+    static getNatural(baseValue: Decimal): ElectricChargeUnit;
+}
+
+/** Options for {@link ElectricCharge.format} and {@link ElectricCharge.normalize}. */
+interface ElectricChargeFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: ElectricChargeUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A electric charge stored internally in ampere-hours,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class ElectricCharge extends Quantity<ElectricChargeUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<ElectricChargeUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: ElectricChargeUnit): this;
+    get milliampereHours(): number;
+    get ampereHours(): number;
+    get coulombs(): number;
+    /** Creates a electric charge from a value and unit. */
+    static create(value: number | Decimal, unit: ElectricChargeUnit): ElectricCharge;
+    static fromMilliampereHours(value: number | Decimal): ElectricCharge;
+    static fromAmpereHours(value: number | Decimal): ElectricCharge;
+    static fromCoulombs(value: number | Decimal): ElectricCharge;
+    static tryParse(input: string | null | undefined): ElectricCharge | null;
+    static parse(input: string): ElectricCharge;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: ElectricChargeFormatOptions): string | null;
+    /** The value in ampere-hours, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: ElectricChargeFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<ElectricCharge>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked electric charge, e.g. `10 Ah` becomes `*** Ah`. */
+declare function maskElectricCharge(value: ElectricCharge): string;
+
+/**
+ * A unit of energy identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class EnergyUnit extends MeasurementUnit {
+    private readonly __energyUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Joule: EnergyUnit;
+    static readonly Kilojoule: EnergyUnit;
+    static readonly Megajoule: EnergyUnit;
+    static readonly Gigajoule: EnergyUnit;
+    static readonly Terajoule: EnergyUnit;
+    static readonly WattHour: EnergyUnit;
+    static readonly KilowattHour: EnergyUnit;
+    static readonly MegawattHour: EnergyUnit;
+    static readonly GigawattHour: EnergyUnit;
+    static readonly TerawattHour: EnergyUnit;
+    static readonly Calorie: EnergyUnit;
+    static readonly Kilocalorie: EnergyUnit;
+    static readonly Btu: EnergyUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<EnergyUnit>;
+    static get all(): readonly EnergyUnit[];
+    /** The base unit: J. */
+    static get baseUnit(): EnergyUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly EnergyUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): EnergyUnit | null;
+    static parse(input: string): EnergyUnit;
+    /** Returns the most human-readable unit for a value in J. */
+    static getNatural(baseValue: Decimal): EnergyUnit;
+}
+
+/** Options for {@link Energy.format} and {@link Energy.normalize}. */
+interface EnergyFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: EnergyUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A energy stored internally in joules,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Energy extends Quantity<EnergyUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<EnergyUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: EnergyUnit): this;
+    get joules(): number;
+    get kilojoules(): number;
+    get megajoules(): number;
+    get gigajoules(): number;
+    get terajoules(): number;
+    get wattHours(): number;
+    get kilowattHours(): number;
+    get megawattHours(): number;
+    get gigawattHours(): number;
+    get terawattHours(): number;
+    get calories(): number;
+    get kilocalories(): number;
+    get btus(): number;
+    /** Creates a energy from a value and unit. */
+    static create(value: number | Decimal, unit: EnergyUnit): Energy;
+    static fromJoules(value: number | Decimal): Energy;
+    static fromKilojoules(value: number | Decimal): Energy;
+    static fromMegajoules(value: number | Decimal): Energy;
+    static fromGigajoules(value: number | Decimal): Energy;
+    static fromTerajoules(value: number | Decimal): Energy;
+    static fromWattHours(value: number | Decimal): Energy;
+    static fromKilowattHours(value: number | Decimal): Energy;
+    static fromMegawattHours(value: number | Decimal): Energy;
+    static fromGigawattHours(value: number | Decimal): Energy;
+    static fromTerawattHours(value: number | Decimal): Energy;
+    static fromCalories(value: number | Decimal): Energy;
+    static fromKilocalories(value: number | Decimal): Energy;
+    static fromBtus(value: number | Decimal): Energy;
+    static tryParse(input: string | null | undefined): Energy | null;
+    static parse(input: string): Energy;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: EnergyFormatOptions): string | null;
+    /** The value in joules, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: EnergyFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Energy>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked energy, e.g. `10 J` becomes `*** J`. */
+declare function maskEnergy(value: Energy): string;
+
+/**
+ * A unit of frequency identified by its symbol.
+ * Each unit carries English and Swedish names, singular and plural forms, and an
+ * exact conversion factor to the base unit.
+ */
+declare class FrequencyUnit extends MeasurementUnit {
+    private readonly __frequencyUnitBrand;
+    static readonly typeInfo: PrimitiveTypeInfo;
+    static readonly Hertz: FrequencyUnit;
+    static readonly Kilohertz: FrequencyUnit;
+    static readonly Megahertz: FrequencyUnit;
+    static readonly Gigahertz: FrequencyUnit;
+    static readonly Terahertz: FrequencyUnit;
+    static readonly RevolutionsPerMinute: FrequencyUnit;
+    /** @internal Shared lookup and natural-scale walk. */
+    static readonly index: MeasurementUnitIndex<FrequencyUnit>;
+    static get all(): readonly FrequencyUnit[];
+    /** The base unit: Hz. */
+    static get baseUnit(): FrequencyUnit;
+    /** Units ordered small to large, used to auto-scale display. */
+    static get naturalScale(): readonly FrequencyUnit[];
+    /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+    static tryParse(input: string | null | undefined): FrequencyUnit | null;
+    static parse(input: string): FrequencyUnit;
+    /** Returns the most human-readable unit for a value in Hz. */
+    static getNatural(baseValue: Decimal): FrequencyUnit;
+}
+
+/** Options for {@link Frequency.format} and {@link Frequency.normalize}. */
+interface FrequencyFormatOptions {
+    fallbackToTrimmedInputWhenInvalid?: boolean;
+    /** Convert to this unit instead of preserving the parsed one. */
+    unit?: FrequencyUnit;
+    /** Round to this many fractional digits, away from zero. */
+    decimals?: number;
+}
+/**
+ * A frequency stored internally in hertz,
+ * parsed from any supported unit and convertible between all of them.
+ */
+declare class Frequency extends Quantity<FrequencyUnit> {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    protected get units(): MeasurementUnitIndex<FrequencyUnit>;
+    protected withBaseValue(baseValue: Decimal, unit: FrequencyUnit): this;
+    get hertz(): number;
+    get kilohertz(): number;
+    get megahertz(): number;
+    get gigahertz(): number;
+    get terahertz(): number;
+    get rpm(): number;
+    /** Creates a frequency from a value and unit. */
+    static create(value: number | Decimal, unit: FrequencyUnit): Frequency;
+    static fromHertz(value: number | Decimal): Frequency;
+    static fromKilohertz(value: number | Decimal): Frequency;
+    static fromMegahertz(value: number | Decimal): Frequency;
+    static fromGigahertz(value: number | Decimal): Frequency;
+    static fromTerahertz(value: number | Decimal): Frequency;
+    static fromRpm(value: number | Decimal): Frequency;
+    static tryParse(input: string | null | undefined): Frequency | null;
+    static parse(input: string): Frequency;
+    static isValid(input: string | null | undefined): boolean;
+    /** Display form in the parsed unit, or `null` when the input is invalid. */
+    static format(input: string | null | undefined, options?: FrequencyFormatOptions): string | null;
+    /** The value in hertz, or `null` when the input is invalid. */
+    static normalize(input: string | null | undefined, options?: FrequencyFormatOptions): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<Frequency>[];
+    private static fallback;
+    private static decimalOf;
+}
+/** Returns a masked frequency, e.g. `10 Hz` becomes `*** Hz`. */
+declare function maskFrequency(value: Frequency): string;
+
+export { DataSize as D, ElectricCharge as E, Frequency as F, type DataSizeFormatOptions as a, DataSizeUnit as b, type ElectricChargeFormatOptions as c, ElectricChargeUnit as d, Energy as e, type EnergyFormatOptions as f, EnergyUnit as g, type FrequencyFormatOptions as h, FrequencyUnit as i, maskElectricCharge as j, maskEnergy as k, maskFrequency as l, maskDataSize as m };