@open-charging-cloud/chargy-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2354 @@
+import * as moment from 'moment';
+import { Moment } from 'moment';
+import Decimal from 'decimal.js';
+import { ec } from 'elliptic';
+
+type JSONLDObject = {
+    "@context": number;
+};
+declare function isJSONLDObject(value: unknown): value is JSONLDObject;
+declare function toArrayBuffer(data: ArrayBuffer | Uint8Array): ArrayBuffer;
+declare function toUint8Array(data: ArrayBuffer | Uint8Array): Uint8Array;
+declare function normalizeXMLText(xmlText: string | undefined): string;
+declare function getDirectChildrenByLocalName(parent: Document | Element, localName: string): Element[];
+declare function getDirectChildByLocalName(parent: Document | Element, localName: string): Element | undefined;
+declare function getTrimmedTextContent(element?: Element): string | undefined;
+declare function parseDescription(parent: Element): IMultilanguageText | undefined;
+declare function getElementsByLocalName(parent: Document | Element, localName: string): Element[];
+declare function ParseJSON_LD(Text: string, _Context?: string): Record<string, unknown>;
+declare function firstKey<T extends Record<string, unknown>>(obj: T): keyof T | undefined;
+declare function firstValue<T>(obj: Record<string, T> | undefined): T | undefined;
+declare function setUILocale(locale: string): void;
+declare function parseUTC(UTCTime: string | number): Moment;
+declare function time2human(Time: string | number): string;
+declare function UTC2human(UTCTime: string | number): string;
+declare function parseOBIS(OBIS: string): string;
+declare const OBIS_RegExpr: RegExp;
+declare function OBIS2Hex(OBIS: string): string;
+declare function OBIS2MeasurementName(OBISString: string): string;
+declare function measurementName2human(In: string): string;
+declare function IsNullOrEmpty(value: string | undefined): boolean;
+declare function WhenNullOrEmpty(value: string | undefined, replacement: string): string;
+declare function hex2bin(hex: string, Reverse?: boolean): string;
+declare function hex32(val: number): string;
+declare function parseHexString(str: string): number[];
+declare function createHexString(arr: Iterable<number>): string;
+declare function buf2hex(buffer: ArrayBuffer | Uint8Array): string;
+declare function hexToArrayBuffer(hex: string): ArrayBuffer;
+declare function hashFile(url: string): Promise<ArrayBuffer>;
+declare function ConcatenateBuffers(buffers: ArrayBuffer[]): ArrayBuffer;
+declare function intFromBytes(x: number[]): number;
+declare function getInt8Bytes(x: number): number[];
+declare function getInt16Bytes(x: number): number[];
+declare function getInt32Bytes(x: number): number[];
+declare function getInt64Bytes(x: number): number[];
+declare function SetHex(dv: DataView, hex: string, offset: number, reverse?: boolean): string;
+declare function SetTimestamp(dv: DataView, timestamp: string | Moment | undefined, offset: number, addLocalOffset?: boolean): string;
+declare function SetTimestamp32(dv: DataView, timestamp: string | Moment | undefined, offset: number, addLocalOffset?: boolean): string;
+declare function SetInt8(dv: DataView, value: number, offset: number): string;
+declare function SetUInt32(dv: DataView, value: number, offset: number, reverse?: boolean): string;
+declare function SetUInt64(dv: DataView, value: number, offset: number, reverse?: boolean): string;
+declare function SetUInt64D(dv: DataView, value: Decimal, offset: number, reverse?: boolean): string;
+declare function SetText(dv: DataView, text: string, offset: number): string;
+declare function SetUInt32_withCode(dv: DataView, value: number, scale: number, obis: number, offset: number, reverse?: boolean): string;
+declare function SetText_withLength(dv: DataView, text: string, offset: number): string;
+declare function Clone<T>(obj: T): T;
+declare function openFullscreen(): void;
+declare function closeFullscreen(): void;
+declare function CreateDiv(ParentDiv: HTMLDivElement, ClassName?: string, InnerHTML?: string): HTMLDivElement;
+declare function CreateDiv2(ParentDiv: HTMLDivElement, ChildClassName: string, ChildAInnerHTML: string, ChildBInnerHTML: string): HTMLDivElement;
+interface String {
+    isNullOrEmpty(): boolean;
+    isNotNullOrEmpty(): boolean;
+}
+declare function pad(text: string | undefined, paddingValue: number): string;
+/**
+ * Calculate the SHA256 hash
+ * @param message a text of data view
+ * @returns true, when the given text exists and is a valid string
+ */
+declare function sha256(message: string | DataView): Promise<string>;
+/**
+ * Calculate the SHA384 hash
+ * @param message a text of data view
+ * @returns true, when the given text exists and is a valid string
+ */
+declare function sha384(message: string | DataView): Promise<string>;
+/**
+ * Calculate the SHA512 hash
+ * @param message a text of data view
+ * @returns true, when the given text exists and is a valid string
+ */
+declare function sha512(message: string | DataView): Promise<string>;
+/**
+ * A JSON object after runtime validation. Property values stay `unknown`
+ * and have to be narrowed individually (e.g. via isMandatoryString).
+ */
+type JSONObject = Record<string, unknown>;
+/**
+ * Returns the given value as a json object, or undefined when it is not a json object.
+ */
+declare function asJSONObject(value: unknown): JSONObject | undefined;
+/**
+ * Returns the given value as a json array, or undefined when it is not a json array.
+ */
+declare function asJSONArray(value: unknown): unknown[] | undefined;
+/**
+ * Returns the given value as a string, or undefined when it is not a string.
+ */
+declare function asString(value: unknown): string | undefined;
+/**
+ * Returns the given value as a number, or undefined when it is not a number.
+ */
+declare function asNumber(value: unknown): number | undefined;
+/**
+ * Ensures, that the given json object exists and is a valid json object
+ * @param value a json object
+ * @returns true, when the given json object exists and is a valid json object
+ */
+declare function isMandatoryJSONObject(value: unknown): value is JSONObject;
+/**
+ * Checks, whether the given json object exists and if yes wether it is a valid json object
+ * @param jsonObject a json object
+ * @returns true, when the given json object does not exist or when it exists, that it is a valid json object
+ */
+declare function isOptionalJSONObject(value: unknown): value is JSONObject | undefined | null;
+/**
+ * Ensures, that the given json array exists and is a valid json array
+ * @param value a json array
+ * @returns true, when the given json array exists and is a valid json array
+ */
+declare function isMandatoryJSONArray(value: unknown): value is unknown[];
+/**
+ * Ensures, that the given json array of strings exists and is a valid json array of strings
+ * @param value a json array of strings
+ * @returns true, when the given json array exists of strings and is a valid json array of strings
+ */
+declare function isMandatoryArrayOfStrings(value: unknown): value is string[];
+/**
+ * Checks, whether the given json array exists and if yes wether it is a valid json array
+ * @param value a json array
+ * @returns true, when the given json array does not exist or when it exists and is a valid json array
+ */
+declare function isOptionalJSONArray(value: unknown): value is unknown[] | undefined | null;
+/**
+ * Checks, whether the given json array of strings exists and if yes wether it is a valid json array of strings
+ * @param value a json array of strings
+ * @returns true, when the given json array of strings does not exist or when it exists and is a valid json array of strings
+ */
+declare function isOptionalArrayOfStrings(value: unknown): value is string[] | undefined | null;
+/**
+ * Checks, whether the given json array exists and if yes wether it is a valid json object
+ * @param jsonArray a json object
+ * @returns true, when the given json array does not exist or when it exists, that it is a valid json array
+ */
+declare function isOptionalJSONArrayError(jsonArray: unknown): boolean;
+/**
+ * Checks, whether the given json array exists and if yes wether it is a valid json object
+ * @param jsonArray a json object
+ * @returns true, when the given json array does not exist or when it exists, that it is a valid json array
+ */
+declare function isOptionalJSONArrayOk(jsonArray: unknown): boolean;
+/**
+ * Ensures, that the given boolean exists and is a valid boolean
+ * @param value a boolean
+ * @returns true, when the given boolean exists and is a valid boolean
+ */
+declare function isMandatoryBoolean(value: unknown): value is boolean;
+/**
+ * Ensures, that the given text exists and is a valid string
+ * @param value a string
+ * @returns true, when the given text exists and is a valid string
+ */
+declare function isMandatoryString(value: unknown): value is string;
+/**
+ * Ensures, that the given text is a valid string, if it exists
+ * @param value a string
+ * @returns true, when the given text is a valid string, if it exists
+ */
+declare function isOptionalString(value: unknown): value is string | undefined | null;
+/**
+ * Ensures, that the given text exists and is a valid URL
+ * @param value an URL
+ * @returns true, when the given text exists and is a valid URL
+ */
+declare function isMandatoryURL(value: unknown): value is string;
+/**
+ * Ensures, that the given text is a valid URL, if it exists
+ * @param value an URL
+ * @returns true, when the given text is a valid URL, if it exists
+ */
+declare function isOptionalURL(value: unknown): value is string | undefined | null;
+/**
+ * Ensures, that the given number exists and is a valid number
+ * @param value a number
+ * @returns true, when the given number exists and is a valid number
+ */
+declare function isMandatoryNumber(value: unknown): value is number;
+/**
+ * Ensures, that the given number is a valid number, if it exists
+ * @param value a number
+ * @returns true, when the given number is a valid number, if it exists
+ */
+declare function isOptionalNumber(value: unknown): value is number | undefined | null;
+/**
+ * Ensures, that the given decimal number exists and is a valid decimal number
+ * @param value a decimal number
+ * @returns true, when the given decimal number exists and is a valid decimal number
+ */
+declare function isMandatoryDecimal(value: unknown): value is Decimal;
+/**
+ * Ensures, that the given decimal number is a valid decimal number, if it exists
+ * @param value a decimal number
+ * @returns true, when the given decimal number is a valid decimal number, if it exists
+ */
+declare function isOptionalDecimal(value: unknown): value is Decimal | undefined | null;
+declare function parseNumber(value: string): number | null;
+declare function InformationRelevanceToString(InfoRelevance: InformationRelevance): string;
+declare function jsonPrettyPrinter(value: unknown, KeyLookup?: (path: string, key: string) => string): string;
+
+declare function isObject(data: unknown): data is Record<string, unknown>;
+declare function isMultilanguageText(data: unknown): data is IMultilanguageText;
+declare function isGeoLocation(data: unknown): data is IGeoLocation;
+interface GetChargingPoolFunc {
+    (Id: string): IChargingPool | null;
+}
+interface GetChargingStationFunc {
+    (Id: string): IChargingStation | null;
+}
+interface GetEVSEFunc {
+    (Id: string): IEVSE | null;
+}
+interface GetMeterFunc {
+    (Id: string): IMeter | null;
+}
+interface CheckMeterPublicKeySignatureFunc {
+    (chargingStation: IChargingStation | null | undefined, evse: IEVSE | null | undefined, meter: IMeter | null | undefined, publicKey: IPublicKey | null | undefined, signature: unknown): Promise<string>;
+}
+interface IContract {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    type?: string;
+    username?: string;
+    email?: string;
+}
+declare function isString(value: unknown): value is string;
+declare function isStringArray(value: unknown): value is string[];
+declare function isStringOrStringArray(value: unknown): value is string | string[];
+interface IOIDInfo {
+    oid: string;
+    name: string;
+}
+declare function isOIDInfo(data: unknown): data is IOIDInfo;
+declare function isStringOrOIDInfo(value: unknown): value is string | IOIDInfo;
+interface IKeyInfo {
+    keyId: string;
+    keyType: string;
+    curve: string;
+    value: string;
+}
+interface IChargingStationOperator {
+    "@id": string;
+    "@context"?: string;
+    subCSOIds?: Array<string>;
+    description?: IMultilanguageText;
+    contact: IContact;
+    support: ISupport;
+    privacy: IPrivacy;
+    geoLocation?: IGeoLocation;
+    chargingPools?: Array<IChargingPool>;
+    chargingStations?: Array<IChargingStation>;
+    EVSEs?: Array<IEVSE>;
+    publicKeys?: Array<IPublicKey>;
+    chargingTariffs?: Array<IChargingTariff>;
+    parkingTariffs?: Array<IParkingTariff>;
+}
+interface IContact {
+    email: string;
+    web: string;
+    logoUrl?: string;
+    address?: IAddress;
+    publicKeys?: Array<IPublicKey>;
+}
+interface ISupport {
+    hotline: string;
+    email: string;
+    web?: string;
+    mediationServices?: Array<string>;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IPrivacy {
+    contact: string;
+    email: string;
+    web: string;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IPublicKey {
+    algorithm: string;
+    format: string;
+    encoding: IEncoding | string;
+    value?: string;
+    previousValue?: string;
+    signatures?: Array<unknown>;
+}
+declare function isIPublicKeyXY(obj: unknown): obj is IPublicKeyXY;
+interface IPublicKeyXY extends IPublicKey {
+    x: string;
+    y: string;
+}
+interface ISignature {
+    algorithm?: CryptoAlgorithms | string;
+    format?: SignatureFormats | string;
+    previousValue?: string;
+    value?: string;
+}
+interface ISignatureRS extends ISignature {
+    r?: string;
+    s?: string;
+}
+interface IChargingPool {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    address?: IAddress;
+    geoLocation?: IGeoLocation;
+    chargingStationOperator?: IChargingStationOperator;
+    chargingStations?: Array<IChargingStation>;
+    chargingTariffs?: Array<IChargingTariff>;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IChargingStation {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    manufacturer?: string;
+    manufacturerURL?: string;
+    model?: string;
+    modelURL?: string;
+    firmwareVersion?: string;
+    firmwareChecksum?: string;
+    hardwareVersion?: string;
+    serialNumber?: string;
+    legalCompliance?: ILegalCompliance;
+    address?: IAddress;
+    geoLocation?: IGeoLocation;
+    chargingStationOperator?: IChargingStationOperator;
+    chargingPoolId?: string;
+    chargingPool?: IChargingPool;
+    EVSEs: Array<IEVSE>;
+    EVSEIds?: Array<string>;
+    meters?: Array<IMeter>;
+    chargingTariffs?: Array<IChargingTariff>;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IEVSE {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    chargingStation?: IChargingStation;
+    chargingStationId?: string;
+    meters: Array<IMeter>;
+    chargingTariffs?: Array<IChargingTariff>;
+    publicKeys?: Array<IPublicKey>;
+    connectors?: Array<IConnector$1>;
+}
+interface IMeter {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    manufacturer?: string;
+    manufacturerURL?: string;
+    model?: string;
+    modelURL?: string;
+    firmwareVersion?: string;
+    firmwareChecksum?: string;
+    hardwareVersion?: string;
+    legalCompliance?: ILegalCompliance;
+    chargingStation?: IChargingStation;
+    chargingStationId?: string;
+    EVSE?: IEVSE;
+    EVSEId?: string;
+    signatureInfos?: ISignatureInfos;
+    signatureFormat?: string;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IConnector$1 {
+    type: string;
+    looses: number;
+}
+interface IConformity {
+    certificateId: string;
+    url?: string;
+    notBefore: string;
+    notAfter: string;
+    officialSoftware?: Array<ITransparencySoftware>;
+    compatibleSoftware?: Array<ITransparencySoftware>;
+    freeText: string;
+}
+interface ICalibration {
+    certificateId: string;
+    url?: string;
+    notBefore: string;
+    notAfter: string;
+    freeText: string;
+}
+interface ILegalCompliance {
+    conformity?: Array<IConformity>;
+    calibration?: Array<ICalibration>;
+    url?: string;
+    freeText: string;
+}
+interface IEMobilityProvider {
+    "@id": string;
+    "@context"?: string;
+    description: IMultilanguageText;
+    chargingTariffs: Array<IChargingTariff>;
+    publicKeys?: Array<IPublicKey>;
+}
+interface ITaxes {
+    "@id": string;
+    "@context"?: string;
+    description?: IMultilanguageText;
+    percentage: number;
+}
+interface IMediationService {
+    "@id": string;
+    "@context"?: string;
+    description: IMultilanguageText;
+    publicKeys?: Array<IPublicKey>;
+}
+interface IChargingProduct {
+    "@id": string;
+    "@context"?: string;
+}
+interface IChargingCosts {
+    total: number;
+    currency: string;
+    reservation?: ICost;
+    energy?: ICost;
+    time?: ICost;
+    idle?: ICost;
+    flat?: IFlatCost;
+}
+interface ICost {
+    amount: number;
+    unit: string;
+    cost: number;
+}
+interface IFlatCost {
+    cost: number;
+}
+interface IParking {
+    "@id": string;
+    "@context"?: string;
+    begin: string;
+    end?: string;
+    overstay?: boolean;
+}
+interface ITransparencySoftware {
+    name: string;
+    version?: string;
+    manufacturer?: string;
+    downloadURLs?: Array<string>;
+}
+interface ITransparencyInfos {
+    chargingSessionURL?: string;
+    officialSoftware?: Array<ITransparencySoftware>;
+    compatibleSoftware?: Array<ITransparencySoftware>;
+    freeText?: string;
+}
+interface IAuthorization {
+    "@id": string;
+    "@context"?: string;
+    type?: string;
+    timestamp?: string;
+    chargingStationOperator?: string;
+    roamingNetwork?: string;
+    eMobilityProvider?: string;
+}
+interface ISignatureInfos {
+    hash: CryptoHashAlgorithms | string;
+    hashTruncation?: number;
+    algorithm: CryptoAlgorithms | string;
+    curve: IECCurves | string;
+    format: SignatureFormats | string;
+    encoding?: IEncoding | string;
+}
+declare enum IECCurves {
+    secp192r1 = "secp192r1",
+    secp224k1 = "secp224k1",
+    secp256k1 = "secp256k1",
+    secp256r1 = "secp256r1",
+    secp384r1 = "secp384r1",
+    secp512r1 = "secp512r1"
+}
+declare enum IEncoding {
+    hex = "hex",
+    base64 = "base64"
+}
+declare enum PublicKeyFormats {
+    DER = "DER",
+    XY = "XY"
+}
+declare enum SignatureFormats {
+    DER = "DER",
+    RS = "RS"
+}
+declare enum CryptoAlgorithms {
+    RSA = "RSA",
+    ECC = "ECC"
+}
+declare enum CryptoHashAlgorithms {
+    SHA256 = "SHA256",
+    SHA384 = "SHA384",
+    SHA512 = "SHA512"
+}
+declare enum DisplayPrefixes {
+    NULL = 0,
+    KILO = 1,
+    MEGA = 2,
+    GIGA = 3
+}
+interface ISessionCryptoResult extends JSONObject {
+    status: SessionVerificationResult;
+    message?: string;
+    exception?: unknown;
+    certainty: number;
+    warnings?: Array<string>;
+    errors?: Array<string>;
+}
+declare function isISessionCryptoResult1(obj: unknown): obj is ISessionCryptoResult;
+declare function isISessionCryptoResult2(obj: unknown): obj is ISessionCryptoResult;
+interface ICryptoResult {
+    status: VerificationResult;
+    errors?: Array<string>;
+    warnings?: Array<string>;
+}
+declare function isICryptoResult(obj: unknown): obj is ICryptoResult;
+interface IAddress {
+    "@context"?: string;
+    city: string;
+    street?: string;
+    houseNumber?: string;
+    floorLevel?: string;
+    postalCode: string;
+    country: string;
+    comment?: string | IMultilanguageText;
+}
+interface IGeoLocation {
+    lat: number;
+    lng: number;
+}
+interface IChargingProductRelevance {
+    time?: InformationRelevance | string;
+    energy?: InformationRelevance | string;
+    parking?: InformationRelevance | string;
+    sessionFee?: InformationRelevance | string;
+}
+declare enum InformationRelevance {
+    Unknown = "Unknown",
+    Ignored = "Ignored",
+    Informative = "Informative",
+    Important = "Important"
+}
+declare enum SessionVerificationResult {
+    Unvalidated = "Unvalidated",
+    UnknownCTRFormat = "UnknownCTRFormat",
+    NoChargeTransparencyRecordsFound = "NoChargeTransparencyRecordsFound",
+    UnknownSessionFormat = "UnknownSessionFormat",
+    InvalidSessionFormat = "InvalidSessionFormat",
+    AtLeastTwoMeasurementsRequired = "AtLeastTwoMeasurementsRequired",
+    InconsistentTimestamps = "InconsistentTimestamps",
+    MissingStartValue = "MissingStartValue",
+    InvalidStartValue = "InvalidStartValue",
+    InvalidIntermediateValue = "InvalidIntermediateValue",
+    MissingStopValue = "MissingStopValue",
+    InvalidStopValue = "InvalidStopValue",
+    EnergyMeterNotFound = "EnergyMeterNotFound",
+    InvalidMeasurement = "InvalidMeasurement",
+    PublicKeyNotFound = "PublicKeyNotFound",
+    UnknownPublicKeyFormat = "UnknownPublicKeyFormat",
+    InvalidPublicKey = "InvalidPublicKey",
+    UnknownSignatureFormat = "UnknownSignatureFormat",
+    InvalidSignature = "InvalidSignature",
+    ValidSignature = "ValidSignature"
+}
+declare enum VerificationResult {
+    Unvalidated = "Unvalidated",
+    NoOperation = "NoOperation",
+    UnknownCTRFormat = "UnknownCTRFormat",
+    EnergyMeterNotFound = "EnergyMeterNotFound",
+    InvalidMeasurement = "InvalidMeasurement",
+    InvalidStartValue = "InvalidStartValue",
+    StartValue = "StartValue",
+    ValidStartValue = "ValidStartValue",
+    InvalidIntermediateValue = "InvalidIntermediateValue",
+    IntermediateValue = "IntermediateValue",
+    ValidIntermediateValue = "ValidIntermediateValue",
+    InvalidStopValue = "InvalidStopValue",
+    StopValue = "StopValue",
+    ValidStopValue = "ValidStopValue",
+    PublicKeyNotFound = "PublicKeyNotFound",
+    UnknownPublicKeyFormat = "UnknownPublicKeyFormat",
+    InvalidPublicKey = "InvalidPublicKey",
+    UnknownSignatureFormat = "UnknownSignatureFormat",
+    InvalidSignature = "InvalidSignature",
+    ValidSignature = "ValidSignature",
+    ValidationError = "ValidationError"
+}
+interface IVersions {
+    name: string;
+    description: IMultilanguageText;
+    versions: Array<IVersion>;
+}
+interface IVersion {
+    version: string;
+    releaseDate: string;
+    description: IMultilanguageText;
+    tags: Array<string>;
+    packages: Array<IVersionPackage>;
+}
+interface IVersionPackage {
+    name: string;
+    description: IMultilanguageText;
+    additionalInfo: unknown;
+    cryptoHashes: ICryptoHashes;
+    signatures: Array<IVersionSignature>;
+    downloadURLs: Record<string, string>;
+}
+interface ICryptoHashes {
+    sha256?: string;
+    sha512?: string;
+}
+interface IVersionSignature {
+    signer: string;
+    timestamp: string;
+    publicKey: string;
+    algorithm: string;
+    format: string;
+    signature: string;
+}
+interface IMultilanguageText {
+    [key: string]: string;
+}
+interface I18NDictionary {
+    [key: string]: IMultilanguageText;
+}
+interface IResult {
+    status: SessionVerificationResult;
+    message: string;
+}
+interface TarInfo {
+    data: ArrayBuffer | Uint8Array;
+    mode: number;
+    mtime: string;
+    path: string;
+    type: string;
+}
+declare function isIFileInfo(obj: unknown): obj is IFileInfo;
+interface IFileInfo {
+    name: string;
+    path?: string;
+    type?: string;
+    data?: ArrayBuffer | Uint8Array;
+    info?: string;
+    error?: string;
+    exception?: unknown;
+}
+interface IChargingPeriod {
+    startTimestamp: string;
+    stopTimestamp?: string;
+    endTimestamp?: string;
+    chargingTariffId: string;
+    activeChargingTariffElement?: IChargingTariffElement;
+    costs: IChargingCosts;
+}
+declare enum DayOfWeek {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6
+}
+interface ITariffRestriction {
+    start_time: string;
+    end_time: string;
+    start_date: string;
+    end_date: string;
+    min_kwh: Decimal;
+    max_kwh: Decimal;
+    min_power: Decimal;
+    max_power: Decimal;
+    min_duration: number;
+    max_duration: number;
+    day_of_week: Array<DayOfWeek>;
+}
+interface IPriceComponent {
+    type: string;
+    price: Decimal;
+    step_size: number;
+}
+interface IChargingTariffElement {
+    price_components: Array<IPriceComponent>;
+    restrictions: ITariffRestriction;
+}
+interface IDisplayText {
+    language: string;
+    text: string;
+}
+interface IChargingTariff {
+    "@id": string;
+    "@context"?: string | Array<string>;
+    country_code?: string;
+    party_id?: string;
+    shortName?: IMultilanguageText;
+    summary?: IMultilanguageText;
+    tariff_alt_url?: string;
+    currency?: string;
+    taxes?: Array<ITaxes>;
+    elements?: Array<IChargingTariffElement>;
+    not_before?: string;
+    not_after?: string;
+    created?: string;
+    last_updated?: string;
+    signatures?: Array<ISignatureRS>;
+}
+interface IParkingTariff {
+    "@id": string;
+    "@context"?: string | Array<string>;
+    country_code?: string;
+    party_id?: string;
+    description?: IMultilanguageText;
+    tariff_alt_text?: Array<IDisplayText>;
+    tariff_alt_url?: string;
+    currency?: string;
+    taxes?: Array<ITaxes>;
+    elements?: Array<IChargingTariffElement>;
+    not_before?: string;
+    not_after?: string;
+    created?: string;
+    last_updated?: string;
+    signatures?: Array<ISignatureRS>;
+}
+type ShowPKIDetailsFunction = (pkiData: unknown) => void;
+type IssueReportPayload = {
+    timestamp: string;
+    chargyVersion: string;
+    platform: string;
+    invalidCTR: boolean;
+    InvalidStationData: boolean;
+    invalidSignatures: boolean;
+    invalidCertificates: boolean;
+    transparencenySoftwareBug: boolean;
+    DSGVO: boolean;
+    BITV: boolean;
+    description: string;
+    chargeTransparencyRecord?: string;
+    name: string;
+    phone: string;
+    eMail: string;
+};
+
+type chargyInterfaces_CheckMeterPublicKeySignatureFunc = CheckMeterPublicKeySignatureFunc;
+type chargyInterfaces_CryptoAlgorithms = CryptoAlgorithms;
+declare const chargyInterfaces_CryptoAlgorithms: typeof CryptoAlgorithms;
+type chargyInterfaces_CryptoHashAlgorithms = CryptoHashAlgorithms;
+declare const chargyInterfaces_CryptoHashAlgorithms: typeof CryptoHashAlgorithms;
+type chargyInterfaces_DayOfWeek = DayOfWeek;
+declare const chargyInterfaces_DayOfWeek: typeof DayOfWeek;
+type chargyInterfaces_DisplayPrefixes = DisplayPrefixes;
+declare const chargyInterfaces_DisplayPrefixes: typeof DisplayPrefixes;
+type chargyInterfaces_GetChargingPoolFunc = GetChargingPoolFunc;
+type chargyInterfaces_GetChargingStationFunc = GetChargingStationFunc;
+type chargyInterfaces_GetEVSEFunc = GetEVSEFunc;
+type chargyInterfaces_GetMeterFunc = GetMeterFunc;
+type chargyInterfaces_I18NDictionary = I18NDictionary;
+type chargyInterfaces_IAddress = IAddress;
+type chargyInterfaces_IAuthorization = IAuthorization;
+type chargyInterfaces_ICalibration = ICalibration;
+type chargyInterfaces_IChargingCosts = IChargingCosts;
+type chargyInterfaces_IChargingPeriod = IChargingPeriod;
+type chargyInterfaces_IChargingPool = IChargingPool;
+type chargyInterfaces_IChargingProduct = IChargingProduct;
+type chargyInterfaces_IChargingProductRelevance = IChargingProductRelevance;
+type chargyInterfaces_IChargingStation = IChargingStation;
+type chargyInterfaces_IChargingStationOperator = IChargingStationOperator;
+type chargyInterfaces_IChargingTariff = IChargingTariff;
+type chargyInterfaces_IChargingTariffElement = IChargingTariffElement;
+type chargyInterfaces_IConformity = IConformity;
+type chargyInterfaces_IContact = IContact;
+type chargyInterfaces_IContract = IContract;
+type chargyInterfaces_ICost = ICost;
+type chargyInterfaces_ICryptoHashes = ICryptoHashes;
+type chargyInterfaces_ICryptoResult = ICryptoResult;
+type chargyInterfaces_IDisplayText = IDisplayText;
+type chargyInterfaces_IECCurves = IECCurves;
+declare const chargyInterfaces_IECCurves: typeof IECCurves;
+type chargyInterfaces_IEMobilityProvider = IEMobilityProvider;
+type chargyInterfaces_IEVSE = IEVSE;
+type chargyInterfaces_IEncoding = IEncoding;
+declare const chargyInterfaces_IEncoding: typeof IEncoding;
+type chargyInterfaces_IFileInfo = IFileInfo;
+type chargyInterfaces_IFlatCost = IFlatCost;
+type chargyInterfaces_IGeoLocation = IGeoLocation;
+type chargyInterfaces_IKeyInfo = IKeyInfo;
+type chargyInterfaces_ILegalCompliance = ILegalCompliance;
+type chargyInterfaces_IMediationService = IMediationService;
+type chargyInterfaces_IMeter = IMeter;
+type chargyInterfaces_IMultilanguageText = IMultilanguageText;
+type chargyInterfaces_IOIDInfo = IOIDInfo;
+type chargyInterfaces_IParking = IParking;
+type chargyInterfaces_IParkingTariff = IParkingTariff;
+type chargyInterfaces_IPriceComponent = IPriceComponent;
+type chargyInterfaces_IPrivacy = IPrivacy;
+type chargyInterfaces_IPublicKey = IPublicKey;
+type chargyInterfaces_IPublicKeyXY = IPublicKeyXY;
+type chargyInterfaces_IResult = IResult;
+type chargyInterfaces_ISessionCryptoResult = ISessionCryptoResult;
+type chargyInterfaces_ISignature = ISignature;
+type chargyInterfaces_ISignatureInfos = ISignatureInfos;
+type chargyInterfaces_ISignatureRS = ISignatureRS;
+type chargyInterfaces_ISupport = ISupport;
+type chargyInterfaces_ITariffRestriction = ITariffRestriction;
+type chargyInterfaces_ITaxes = ITaxes;
+type chargyInterfaces_ITransparencyInfos = ITransparencyInfos;
+type chargyInterfaces_ITransparencySoftware = ITransparencySoftware;
+type chargyInterfaces_IVersion = IVersion;
+type chargyInterfaces_IVersionPackage = IVersionPackage;
+type chargyInterfaces_IVersionSignature = IVersionSignature;
+type chargyInterfaces_IVersions = IVersions;
+type chargyInterfaces_InformationRelevance = InformationRelevance;
+declare const chargyInterfaces_InformationRelevance: typeof InformationRelevance;
+type chargyInterfaces_IssueReportPayload = IssueReportPayload;
+type chargyInterfaces_PublicKeyFormats = PublicKeyFormats;
+declare const chargyInterfaces_PublicKeyFormats: typeof PublicKeyFormats;
+type chargyInterfaces_SessionVerificationResult = SessionVerificationResult;
+declare const chargyInterfaces_SessionVerificationResult: typeof SessionVerificationResult;
+type chargyInterfaces_ShowPKIDetailsFunction = ShowPKIDetailsFunction;
+type chargyInterfaces_SignatureFormats = SignatureFormats;
+declare const chargyInterfaces_SignatureFormats: typeof SignatureFormats;
+type chargyInterfaces_TarInfo = TarInfo;
+type chargyInterfaces_VerificationResult = VerificationResult;
+declare const chargyInterfaces_VerificationResult: typeof VerificationResult;
+declare const chargyInterfaces_isGeoLocation: typeof isGeoLocation;
+declare const chargyInterfaces_isICryptoResult: typeof isICryptoResult;
+declare const chargyInterfaces_isIFileInfo: typeof isIFileInfo;
+declare const chargyInterfaces_isIPublicKeyXY: typeof isIPublicKeyXY;
+declare const chargyInterfaces_isISessionCryptoResult1: typeof isISessionCryptoResult1;
+declare const chargyInterfaces_isISessionCryptoResult2: typeof isISessionCryptoResult2;
+declare const chargyInterfaces_isMultilanguageText: typeof isMultilanguageText;
+declare const chargyInterfaces_isOIDInfo: typeof isOIDInfo;
+declare const chargyInterfaces_isObject: typeof isObject;
+declare const chargyInterfaces_isString: typeof isString;
+declare const chargyInterfaces_isStringArray: typeof isStringArray;
+declare const chargyInterfaces_isStringOrOIDInfo: typeof isStringOrOIDInfo;
+declare const chargyInterfaces_isStringOrStringArray: typeof isStringOrStringArray;
+declare namespace chargyInterfaces {
+  export { type chargyInterfaces_CheckMeterPublicKeySignatureFunc as CheckMeterPublicKeySignatureFunc, chargyInterfaces_CryptoAlgorithms as CryptoAlgorithms, chargyInterfaces_CryptoHashAlgorithms as CryptoHashAlgorithms, chargyInterfaces_DayOfWeek as DayOfWeek, chargyInterfaces_DisplayPrefixes as DisplayPrefixes, type chargyInterfaces_GetChargingPoolFunc as GetChargingPoolFunc, type chargyInterfaces_GetChargingStationFunc as GetChargingStationFunc, type chargyInterfaces_GetEVSEFunc as GetEVSEFunc, type chargyInterfaces_GetMeterFunc as GetMeterFunc, type chargyInterfaces_I18NDictionary as I18NDictionary, type chargyInterfaces_IAddress as IAddress, type chargyInterfaces_IAuthorization as IAuthorization, type chargyInterfaces_ICalibration as ICalibration, type chargyInterfaces_IChargingCosts as IChargingCosts, type chargyInterfaces_IChargingPeriod as IChargingPeriod, type chargyInterfaces_IChargingPool as IChargingPool, type chargyInterfaces_IChargingProduct as IChargingProduct, type chargyInterfaces_IChargingProductRelevance as IChargingProductRelevance, type chargyInterfaces_IChargingStation as IChargingStation, type chargyInterfaces_IChargingStationOperator as IChargingStationOperator, type chargyInterfaces_IChargingTariff as IChargingTariff, type chargyInterfaces_IChargingTariffElement as IChargingTariffElement, type chargyInterfaces_IConformity as IConformity, type IConnector$1 as IConnector, type chargyInterfaces_IContact as IContact, type chargyInterfaces_IContract as IContract, type chargyInterfaces_ICost as ICost, type chargyInterfaces_ICryptoHashes as ICryptoHashes, type chargyInterfaces_ICryptoResult as ICryptoResult, type chargyInterfaces_IDisplayText as IDisplayText, chargyInterfaces_IECCurves as IECCurves, type chargyInterfaces_IEMobilityProvider as IEMobilityProvider, type chargyInterfaces_IEVSE as IEVSE, chargyInterfaces_IEncoding as IEncoding, type chargyInterfaces_IFileInfo as IFileInfo, type chargyInterfaces_IFlatCost as IFlatCost, type chargyInterfaces_IGeoLocation as IGeoLocation, type chargyInterfaces_IKeyInfo as IKeyInfo, type chargyInterfaces_ILegalCompliance as ILegalCompliance, type chargyInterfaces_IMediationService as IMediationService, type chargyInterfaces_IMeter as IMeter, type chargyInterfaces_IMultilanguageText as IMultilanguageText, type chargyInterfaces_IOIDInfo as IOIDInfo, type chargyInterfaces_IParking as IParking, type chargyInterfaces_IParkingTariff as IParkingTariff, type chargyInterfaces_IPriceComponent as IPriceComponent, type chargyInterfaces_IPrivacy as IPrivacy, type chargyInterfaces_IPublicKey as IPublicKey, type chargyInterfaces_IPublicKeyXY as IPublicKeyXY, type chargyInterfaces_IResult as IResult, type chargyInterfaces_ISessionCryptoResult as ISessionCryptoResult, type chargyInterfaces_ISignature as ISignature, type chargyInterfaces_ISignatureInfos as ISignatureInfos, type chargyInterfaces_ISignatureRS as ISignatureRS, type chargyInterfaces_ISupport as ISupport, type chargyInterfaces_ITariffRestriction as ITariffRestriction, type chargyInterfaces_ITaxes as ITaxes, type chargyInterfaces_ITransparencyInfos as ITransparencyInfos, type chargyInterfaces_ITransparencySoftware as ITransparencySoftware, type chargyInterfaces_IVersion as IVersion, type chargyInterfaces_IVersionPackage as IVersionPackage, type chargyInterfaces_IVersionSignature as IVersionSignature, type chargyInterfaces_IVersions as IVersions, chargyInterfaces_InformationRelevance as InformationRelevance, type chargyInterfaces_IssueReportPayload as IssueReportPayload, chargyInterfaces_PublicKeyFormats as PublicKeyFormats, chargyInterfaces_SessionVerificationResult as SessionVerificationResult, type chargyInterfaces_ShowPKIDetailsFunction as ShowPKIDetailsFunction, chargyInterfaces_SignatureFormats as SignatureFormats, type chargyInterfaces_TarInfo as TarInfo, chargyInterfaces_VerificationResult as VerificationResult, chargyInterfaces_isGeoLocation as isGeoLocation, chargyInterfaces_isICryptoResult as isICryptoResult, chargyInterfaces_isIFileInfo as isIFileInfo, chargyInterfaces_isIPublicKeyXY as isIPublicKeyXY, chargyInterfaces_isISessionCryptoResult1 as isISessionCryptoResult1, chargyInterfaces_isISessionCryptoResult2 as isISessionCryptoResult2, chargyInterfaces_isMultilanguageText as isMultilanguageText, chargyInterfaces_isOIDInfo as isOIDInfo, chargyInterfaces_isObject as isObject, chargyInterfaces_isString as isString, chargyInterfaces_isStringArray as isStringArray, chargyInterfaces_isStringOrOIDInfo as isStringOrOIDInfo, chargyInterfaces_isStringOrStringArray as isStringOrStringArray };
+}
+
+declare const ChargeTransparencyLiveLinkContext = "https://open.charging.cloud/contexts/chargeTransparency/live/link/1.0";
+declare function IsAChargeTransparencyLiveLink(data: unknown): data is IChargeTransparencyLiveLink;
+interface IChargeTransparencyLiveLink extends JSONObject {
+    "@context": typeof ChargeTransparencyLiveLinkContext;
+    /** ISO 8601 timestamp */
+    timestamp?: string | null;
+    /** Multi-language description */
+    description?: IMultilanguageText;
+    /** URLs to images / logos */
+    imageURLs?: string[];
+    /** Geographic position of the charging station */
+    geoLocation?: IGeoLocation;
+    /** Technical connector data */
+    connector?: IConnector;
+    /** Available transport methods for live data */
+    transports?: Transport[];
+    /** Digital signatures (currently empty or extendable) */
+    signatures?: ISignature[];
+}
+/** Connector information */
+interface IConnector {
+    standard?: string;
+    format?: string;
+    powerType?: string;
+    maxPower?: string;
+}
+/** Union type for the different transport variants */
+type Transport = TransportHTTPS | TransportHTTPSSE | TransportWebsocket;
+interface ITransport {
+    url?: string;
+    urls?: Array<ITransportURL | string>;
+    totp?: TOTPConfig;
+}
+interface TransportHTTPS extends ITransport {
+    type: "https";
+}
+interface TransportHTTPSSE extends ITransport {
+    type: "httpSSE";
+}
+interface TransportWebsocket extends ITransport {
+    type: "websocket";
+}
+interface ITransportURL {
+    url: string;
+    priority?: number;
+    weight?: number;
+}
+/** Time-based One-Time Password configuration */
+interface TOTPConfig {
+    initialSharedSecret: string;
+    timeStep: number;
+}
+
+declare const IChargeTransparencyLiveLink$1_ChargeTransparencyLiveLinkContext: typeof ChargeTransparencyLiveLinkContext;
+type IChargeTransparencyLiveLink$1_IChargeTransparencyLiveLink = IChargeTransparencyLiveLink;
+type IChargeTransparencyLiveLink$1_IConnector = IConnector;
+type IChargeTransparencyLiveLink$1_ITransport = ITransport;
+type IChargeTransparencyLiveLink$1_ITransportURL = ITransportURL;
+declare const IChargeTransparencyLiveLink$1_IsAChargeTransparencyLiveLink: typeof IsAChargeTransparencyLiveLink;
+type IChargeTransparencyLiveLink$1_TOTPConfig = TOTPConfig;
+type IChargeTransparencyLiveLink$1_Transport = Transport;
+type IChargeTransparencyLiveLink$1_TransportHTTPS = TransportHTTPS;
+type IChargeTransparencyLiveLink$1_TransportHTTPSSE = TransportHTTPSSE;
+type IChargeTransparencyLiveLink$1_TransportWebsocket = TransportWebsocket;
+declare namespace IChargeTransparencyLiveLink$1 {
+  export { IChargeTransparencyLiveLink$1_ChargeTransparencyLiveLinkContext as ChargeTransparencyLiveLinkContext, type IChargeTransparencyLiveLink$1_IChargeTransparencyLiveLink as IChargeTransparencyLiveLink, type IChargeTransparencyLiveLink$1_IConnector as IConnector, type IChargeTransparencyLiveLink$1_ITransport as ITransport, type IChargeTransparencyLiveLink$1_ITransportURL as ITransportURL, IChargeTransparencyLiveLink$1_IsAChargeTransparencyLiveLink as IsAChargeTransparencyLiveLink, type IChargeTransparencyLiveLink$1_TOTPConfig as TOTPConfig, type IChargeTransparencyLiveLink$1_Transport as Transport, type IChargeTransparencyLiveLink$1_TransportHTTPS as TransportHTTPS, type IChargeTransparencyLiveLink$1_TransportHTTPSSE as TransportHTTPSSE, type IChargeTransparencyLiveLink$1_TransportWebsocket as TransportWebsocket };
+}
+
+declare function IsAPublicKeyLookup(data: unknown): data is IPublicKeyLookup;
+interface IPublicKeyLookup extends JSONObject {
+    publicKeys: Array<IPublicKeyInfo>;
+    status?: SessionVerificationResult;
+}
+declare function IsAPublicKeyInfo(data: unknown): data is IPublicKeyInfo;
+interface IPublicKeyInfo extends JSONObject {
+    "@id"?: string;
+    "@context": string;
+    subject?: string;
+    type?: string | IOIDInfo;
+    algorithm: string | IOIDInfo;
+    value: string;
+    encoding?: string;
+    signatures?: Array<IPublicKeysignature>;
+    certainty?: number;
+}
+interface IPublicKeysignature {
+    "@id": string;
+    "@context"?: string;
+    timestamp: string;
+    keyUsage: Array<string>;
+}
+
+type IPublicKeyInfo$1_IPublicKeyInfo = IPublicKeyInfo;
+type IPublicKeyInfo$1_IPublicKeyLookup = IPublicKeyLookup;
+type IPublicKeyInfo$1_IPublicKeysignature = IPublicKeysignature;
+declare const IPublicKeyInfo$1_IsAPublicKeyInfo: typeof IsAPublicKeyInfo;
+declare const IPublicKeyInfo$1_IsAPublicKeyLookup: typeof IsAPublicKeyLookup;
+declare namespace IPublicKeyInfo$1 {
+  export { type IPublicKeyInfo$1_IPublicKeyInfo as IPublicKeyInfo, type IPublicKeyInfo$1_IPublicKeyLookup as IPublicKeyLookup, type IPublicKeyInfo$1_IPublicKeysignature as IPublicKeysignature, IPublicKeyInfo$1_IsAPublicKeyInfo as IsAPublicKeyInfo, IPublicKeyInfo$1_IsAPublicKeyLookup as IsAPublicKeyLookup };
+}
+
+declare function IsAChargeTransparencyRecord(data: unknown): data is IChargeTransparencyRecord;
+interface IChargeTransparencyRecord extends JSONObject {
+    "@id": string;
+    "@context": string | Array<string>;
+    begin?: string;
+    end?: string;
+    description?: IMultilanguageText;
+    contract?: IContract;
+    chargingStationOperators?: Array<IChargingStationOperator>;
+    chargingPools?: Array<IChargingPool>;
+    chargingStations?: Array<IChargingStation>;
+    chargingTariffs?: Array<IChargingTariff>;
+    publicKeys?: Array<IPublicKeyInfo>;
+    chargingSessions?: Array<IChargingSession>;
+    eMobilityProviders?: Array<IEMobilityProvider>;
+    mediationServices?: Array<IMediationService>;
+    verificationResult?: ISessionCryptoResult;
+    invalidDataSets?: Array<IExtendedFileInfo>;
+    certainty: number;
+    warnings?: Array<string>;
+    errors?: Array<string>;
+    status?: SessionVerificationResult;
+}
+declare function IsASessionCryptoResult(data: unknown): data is ISessionCryptoResult;
+interface IChargingSession {
+    "@id": string;
+    "@context"?: string;
+    ctr?: IChargeTransparencyRecord;
+    GUI?: HTMLDivElement;
+    begin: string;
+    end?: string;
+    internalSessionId?: string;
+    chargingProductRelevance?: IChargingProductRelevance;
+    description?: IMultilanguageText;
+    chargingStationOperatorId?: string;
+    chargingStationOperator?: IChargingStationOperator;
+    chargingPoolId?: string;
+    chargingPool?: IChargingPool;
+    chargingStationId?: string;
+    chargingStation?: IChargingStation;
+    EVSEId: string;
+    EVSE?: IEVSE;
+    meterId?: string;
+    meter?: IMeter;
+    publicKey?: IPublicKeyInfo;
+    tariffId?: string;
+    chargingTariffs?: Array<IChargingTariff>;
+    chargingPeriods?: Array<IChargingPeriod>;
+    totalCosts?: IChargingCosts;
+    authorizationStart: IAuthorization;
+    authorizationStop?: IAuthorization;
+    product?: IChargingProduct;
+    measurements: Array<IMeasurement>;
+    parking?: Array<IParking>;
+    transparencyInfos?: ITransparencyInfos;
+    method?: ACrypt;
+    original?: string;
+    signature?: string | ISignatureRS;
+    hashValue?: string;
+    verificationResult?: ISessionCryptoResult;
+}
+interface IMeasurement {
+    "@context"?: string;
+    chargingSession?: IChargingSession;
+    energyMeterId: string;
+    phenomena?: any[];
+    name: string;
+    obis: string;
+    unit?: string;
+    unitEncoded?: number;
+    valueType?: string;
+    scale: number;
+    verifyChain?: boolean;
+    signatureInfos?: ISignatureInfos;
+    values: Array<IMeasurementValue>;
+    verificationResult?: ICryptoResult;
+}
+interface IMeasurements {
+    "@context"?: string;
+    values: Array<IMeasurement>;
+    verificationResult?: ICryptoResult;
+}
+interface IMeasurementValue {
+    measurement?: IMeasurement;
+    method?: ACrypt;
+    previousValue?: IMeasurementValue;
+    timestamp: string;
+    value: Decimal;
+    value_displayPrefix?: DisplayPrefixes;
+    value_displayPrecision?: number;
+    statusMeter?: string;
+    secondsIndex?: number;
+    paginationId?: number | string;
+    logBookIndex?: string;
+    statusAdapter?: string;
+    errors?: Array<string>;
+    warnings?: Array<string>;
+    signatures?: Array<ISignature | ISignatureRS>;
+    result?: ICryptoResult;
+}
+interface IExtendedFileInfo extends IFileInfo {
+    result: IChargeTransparencyRecord | IChargeTransparencyLiveLink | IPublicKeyInfo | IPublicKeyLookup | ISessionCryptoResult;
+}
+declare function CloneCTR(CTR: IChargeTransparencyRecord): IChargeTransparencyRecord;
+
+declare const IChargeTransparencyRecord$1_CloneCTR: typeof CloneCTR;
+type IChargeTransparencyRecord$1_IChargeTransparencyRecord = IChargeTransparencyRecord;
+type IChargeTransparencyRecord$1_IChargingSession = IChargingSession;
+type IChargeTransparencyRecord$1_IExtendedFileInfo = IExtendedFileInfo;
+type IChargeTransparencyRecord$1_IMeasurement = IMeasurement;
+type IChargeTransparencyRecord$1_IMeasurementValue = IMeasurementValue;
+type IChargeTransparencyRecord$1_IMeasurements = IMeasurements;
+declare const IChargeTransparencyRecord$1_IsAChargeTransparencyRecord: typeof IsAChargeTransparencyRecord;
+declare const IChargeTransparencyRecord$1_IsASessionCryptoResult: typeof IsASessionCryptoResult;
+declare namespace IChargeTransparencyRecord$1 {
+  export { IChargeTransparencyRecord$1_CloneCTR as CloneCTR, type IChargeTransparencyRecord$1_IChargeTransparencyRecord as IChargeTransparencyRecord, type IChargeTransparencyRecord$1_IChargingSession as IChargingSession, type IChargeTransparencyRecord$1_IExtendedFileInfo as IExtendedFileInfo, type IChargeTransparencyRecord$1_IMeasurement as IMeasurement, type IChargeTransparencyRecord$1_IMeasurementValue as IMeasurementValue, type IChargeTransparencyRecord$1_IMeasurements as IMeasurements, IChargeTransparencyRecord$1_IsAChargeTransparencyRecord as IsAChargeTransparencyRecord, IChargeTransparencyRecord$1_IsASessionCryptoResult as IsASessionCryptoResult };
+}
+
+type Asn1Builder = {
+    bitstr(): Asn1Builder;
+    int(): Asn1Builder;
+    key(name: string): Asn1Builder;
+    obj(...items: unknown[]): Asn1Builder;
+    objid(): Asn1Builder;
+    seq(): Asn1Builder;
+    seqof(schema: unknown): Asn1Builder;
+};
+type Asn1Schema = {
+    decode<T = any>(data: Uint8Array | ArrayBuffer, encoding: string): T;
+};
+type Asn1Module = {
+    define: (name: string, body: (this: Asn1Builder) => void) => Asn1Schema;
+};
+type Base32Decode = (input: string, variant: "RFC3548" | "RFC4648" | "RFC4648-HEX" | "Crockford") => ArrayBuffer;
+type EllipticKeyPair = {
+    verify(hash: string, signature: unknown): boolean;
+};
+type EllipticCurve = {
+    keyFromPublic(publicKey: string | {
+        x: string;
+        y: string;
+    }, encoding: string): EllipticKeyPair;
+};
+type EllipticModule = {
+    ec: new (curve: string) => EllipticCurve;
+};
+type MomentModule = typeof moment;
+declare class Chargy {
+    readonly i18n: I18NDictionary;
+    UILanguage: string;
+    readonly elliptic: EllipticModule;
+    readonly moment: MomentModule;
+    readonly asn1: Asn1Module;
+    readonly base32Decode: Base32Decode;
+    readonly showPKIDetails: ShowPKIDetailsFunction;
+    private chargingStationOperators;
+    private chargingPools;
+    private chargingStations;
+    private EVSEs;
+    private meters;
+    private chargingSessions;
+    private eMobilityProviders;
+    private mediationServices;
+    currentCTR: IChargeTransparencyRecord;
+    internalCTR: IChargeTransparencyRecord;
+    constructor(i18n: I18NDictionary, UILanguage: string, elliptic: EllipticModule, moment: MomentModule, asn1: Asn1Module, base32Decode: Base32Decode, ShowPKIDetails: ShowPKIDetailsFunction);
+    SetUILanguage(UILanguage: string): void;
+    private PublicKeyIdFromFileName;
+    private TryToParseDERPublicKey;
+    private IsHexEncodedPublicKeyFile;
+    private TryToGetDERPublicKeyHEX;
+    private isSupportedQRCodeImageFile;
+    private fileNameWithoutExtension;
+    private textFileNameForQRCodeContent;
+    private tryExtractChargeTransparencyTextFromURL;
+    private tryExtractSignedDataTextFromXML;
+    private expandQRCodeImageFiles;
+    GetLocalizedMessage(Text: string): string;
+    GetLocalizedMessageWithParameter(Text: string, Parameter: string | number): string;
+    GetChargingPool: GetChargingPoolFunc;
+    GetChargingStation: GetChargingStationFunc;
+    GetEVSE: GetEVSEFunc;
+    GetMeter: GetMeterFunc;
+    CheckMeterPublicKeySignature(chargingStation: IChargingStation | null | undefined, evse: IEVSE | null | undefined, meter: IMeter | null | undefined, publicKey: IPublicKey | null | undefined, signature: unknown): Promise<string>;
+    private decompressFiles;
+    private extractArchive;
+    private extractTarArchive;
+    private extractZipArchive;
+    private decompressStream;
+    private findZipEndOfCentralDirectory;
+    private toUint8Array;
+    private readTarString;
+    private readTarOctal;
+    DetectAndConvertContentFormat(FileInfos: Array<IFileInfo>): Promise<IChargeTransparencyRecord | IChargeTransparencyLiveLink | IPublicKeyInfo | ISessionCryptoResult>;
+    private processChargeTransparencyRecord;
+    private processChargingSession;
+    MergeChargeTransparencyRecords(CTRs: Array<IChargeTransparencyRecord>): IChargeTransparencyRecord;
+}
+
+declare class secp224k1 {
+    private Zero;
+    private One;
+    private Two;
+    private Three;
+    private Pcurve;
+    private N;
+    private Acurve;
+    private Bcurve;
+    private Gx;
+    private Gy;
+    private GPoint;
+    Sign(hash: bigint, RandomNumber: bigint, privateKey: bigint): Array<bigint> | null;
+    validate(hash: bigint, signatureR: bigint, signatureS: bigint, PublicKey: Array<bigint>): boolean;
+    modulo(n: bigint, m: bigint): bigint;
+    zfill(s: string): string;
+    modInv(a: bigint, n?: bigint): bigint;
+    ECadd(a: Array<bigint>, b: Array<bigint>): Array<bigint>;
+    ECdouble(a: Array<bigint>): Array<bigint>;
+    ECmultiply(GenPoint: Array<bigint>, ScalarHex: bigint): Array<bigint>;
+    PublicKeyGenerate(PrivateKey: string | number | bigint): {
+        x: bigint;
+        y: bigint;
+        xy: Array<string>;
+        uncompressed: string;
+        compressed: string;
+        address: string;
+    } | undefined;
+}
+
+declare abstract class ACrypt {
+    readonly description: string;
+    readonly chargy: Chargy;
+    readonly curve192r1: EllipticCurve;
+    readonly curve224k1: secp224k1;
+    readonly curve256r1: EllipticCurve;
+    readonly curve384r1: EllipticCurve;
+    readonly curve521r1: EllipticCurve;
+    constructor(description: string, chargy: Chargy);
+    protected CreateLocalizedLine(id: string, value: string | number, valueHEX: string, infoDiv: HTMLDivElement, bufferDiv: HTMLDivElement): void;
+    protected CreateLine(id: string, value: string | number, valueHEX: string, infoDiv: HTMLDivElement, bufferDiv: HTMLDivElement): void;
+    protected AddToVisualBuffer(valueHEX: string, bufferDiv: HTMLDivElement, lineDiv: HTMLDivElement): void;
+    abstract VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    abstract VerifyMeasurement(measurementValue: IMeasurementValue): Promise<ICryptoResult>;
+    abstract ViewMeasurement(measurementValue: IMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, bufferValue: HTMLDivElement, hashedBufferValue: HTMLDivElement, publicKeyValue: HTMLDivElement, signatureExpectedValue: HTMLDivElement, signatureCheckValue: HTMLDivElement): Promise<Error | undefined>;
+}
+
+declare class Alfen {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    private bufferToHex;
+    private bufferToNumber;
+    TryToParseALFENFormat(Content: string | string[], ContainerInfos: unknown): IChargeTransparencyRecord | ISessionCryptoResult;
+}
+interface IAlfenMeasurement extends IMeasurement {
+    adapterId: string;
+    adapterFWVersion: string;
+    adapterFWChecksum: string;
+}
+interface IAlfenMeasurementValue extends IMeasurementValue {
+    statusMeter: string;
+    statusAdapter: string;
+    secondsIndex: number;
+    sessionId: string;
+    paginationId: number;
+    measurement: IAlfenMeasurement;
+}
+interface IAlfenCrypt01Result extends ICryptoResult {
+    adapterId?: string;
+    adapterFWVersion?: string;
+    adapterFWChecksum?: string;
+    meterId?: string;
+    meter?: IMeter;
+    statusMeter?: string;
+    statusAdapter?: string;
+    secondsIndex?: string;
+    timestamp?: string;
+    obisId?: string;
+    unitEncoded?: string;
+    scalar?: string;
+    value?: string;
+    uid?: string;
+    sessionId?: string;
+    paging?: string;
+    hashValue?: string | bigint;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+interface IAlfenChargingSession extends IChargingSession {
+    internalSessionId?: string;
+    meter?: IMeter;
+    measurements: Array<IAlfenMeasurement>;
+}
+interface IAlfenChargeTransparencyRecord extends IChargeTransparencyRecord {
+    chargingSessions?: Array<IAlfenChargingSession>;
+}
+declare class AlfenCrypt01 extends ACrypt {
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IAlfenMeasurementValue): Promise<IAlfenCrypt01Result>;
+    ViewMeasurement(measurementValue: IAlfenMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+    private DecodeMeterStatus;
+    private DecodeAdapterStatus;
+}
+
+interface IBSMMeasurementValue extends IMeasurementValue {
+    Typ: number;
+    RCR: number;
+    RCR_SF: number;
+    RCR_Unit: string;
+    RCR_Prefix: DisplayPrefixes;
+    RCR_Precision: number;
+    TotWhImp: number;
+    TotWhImp_SF: number;
+    TotWhImp_Unit: string;
+    TotWhImp_Prefix: DisplayPrefixes;
+    TotWhImp_Precision: number;
+    W: number;
+    W_SF: number;
+    W_Unit: string;
+    W_Prefix: DisplayPrefixes;
+    W_Precision: number;
+    MA1: string;
+    RCnt: number;
+    OS: number;
+    Epoch: number;
+    TZO: number;
+    EpochSetCnt: number;
+    EpochSetOS: number;
+    DI: number;
+    DO: number;
+    Meta1: string;
+    Meta2: string;
+    Meta3: string;
+    Evt: number;
+}
+interface IBSMCrypt01Result extends ICryptoResult {
+    sha256value?: string;
+    meterId?: string;
+    meter?: IMeter;
+    timestamp?: string;
+    ArraySize: number;
+    Typ: string;
+    RCR: string;
+    TotWhImp: string;
+    W: string;
+    MA1: string;
+    RCnt: string;
+    OS: string;
+    Epoch: string;
+    TZO: string;
+    EpochSetCnt: string;
+    EpochSetOS: string;
+    DI: string;
+    DO: string;
+    Meta1: string;
+    Meta2: string;
+    Meta3: string;
+    Evt: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+declare class BSMCrypt01 extends ACrypt {
+    readonly curve: EllipticCurve;
+    constructor(chargy: Chargy);
+    tryToParseBSM_WS36aMeasurements(CTR: IChargeTransparencyRecord, ExpectedEVSEId: string, ExpectedCscSwVersion: string | null, Measurements: Array<unknown>): IChargeTransparencyRecord | ISessionCryptoResult;
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IBSMMeasurementValue): Promise<IBSMCrypt01Result>;
+    ViewMeasurement(measurementValue: IBSMMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+    private PrefixConverter;
+    private UnitConverter;
+    ParseTyp(value: number): string;
+    ParseEvents(value: number): string[];
+    private DecodeStatus;
+}
+
+declare class CanonicalJSONError extends TypeError {
+    constructor(message: string);
+}
+/**
+ * Deterministic RFC 8259 JSON serialization for signature input.
+ *
+ * Objects are emitted with ordinally sorted property names, arrays keep their
+ * original order, and no insignificant whitespace is written. This is meant
+ * as a stable JSON byte representation; it is intentionally strict about
+ * values which are not representable as RFC 8259 JSON.
+ */
+declare function canonicalJSONStringify(value: unknown): string;
+declare function canonicalJSONBytes(value: unknown): Uint8Array;
+
+type JSONMessage = Record<string, unknown>;
+interface JSONSignature {
+    publicKey: string;
+    publicKeyHEX: string;
+    signature: string;
+    signatureHEX: string;
+}
+interface SignedJSONMessage extends JSONMessage {
+    signatures?: JSONSignature[];
+}
+declare enum JSONSignatureVerificationStatus {
+    True = "True",
+    False = "False",
+    InvalidJSON = "InvalidJSON",
+    MissingSignatures = "MissingSignatures",
+    InvalidSignaturesArray = "InvalidSignaturesArray",
+    InvalidSignatureStructure = "InvalidSignatureStructure",
+    InvalidSignatureEncoding = "InvalidSignatureEncoding",
+    InvalidPublicKey = "InvalidPublicKey",
+    InvalidSignature = "InvalidSignature",
+    InvalidCanonicalJSON = "InvalidCanonicalJSON"
+}
+interface JSONSignatureVerificationResult {
+    status: JSONSignatureVerificationStatus;
+    description?: string;
+}
+interface JSONMessageSignaturesVerificationResult {
+    status: JSONSignatureVerificationStatus;
+    description?: string;
+    signatures: Record<string, JSONSignatureVerificationResult>;
+}
+interface SignJSONMessageOptions {
+    curve?: string;
+    canonical?: boolean;
+    signatureFormat?: "DER";
+}
+declare function signMessage(JSONMessage: SignedJSONMessage, ...KeyPairs: ec.KeyPair[]): Promise<boolean>;
+declare function SignMessage(JSONMessage: SignedJSONMessage, ...KeyPairs: ec.KeyPair[]): Promise<boolean>;
+declare function signJSONMessage(JSONMessage: SignedJSONMessage | null | undefined, KeyPairs: Array<ec.KeyPair | null | undefined> | null | undefined, options?: SignJSONMessageOptions): Promise<boolean>;
+declare function verifyJSONSignature(JSONMessage: SignedJSONMessage, signature: JSONSignature, options?: SignJSONMessageOptions): Promise<boolean>;
+declare function verifyJSONSignatureResult(JSONMessage: SignedJSONMessage | null | undefined, signature: unknown, options?: SignJSONMessageOptions): Promise<JSONSignatureVerificationResult>;
+declare function verifyJSONMessageSignatures(JSONMessage: unknown, options?: SignJSONMessageOptions): Promise<boolean>;
+declare function verifyJSONMessageSignatureResults(JSONMessage: unknown, options?: SignJSONMessageOptions): Promise<JSONMessageSignaturesVerificationResult>;
+declare function VerifyJSONMessageSignatures(JSONMessage: unknown, options?: SignJSONMessageOptions): Promise<boolean>;
+declare function parseAndVerifyJSONSignatures(JSONMessage: string, options?: SignJSONMessageOptions): Promise<boolean>;
+
+interface IEMHMeasurementValue extends IMeasurementValue {
+    infoStatus: string;
+    secondsIndex: number;
+    paginationId: string;
+    logBookIndex: string;
+}
+interface IEMHCrypt01Result extends ICryptoResult {
+    sha256value?: string;
+    meterId?: string;
+    meter?: IMeter;
+    timestamp?: string;
+    infoStatus?: string;
+    secondsIndex?: string;
+    paginationId?: string;
+    obis?: string;
+    unitEncoded?: string;
+    scale?: string;
+    value?: string;
+    logBookIndex?: string;
+    authorizationStart?: string;
+    authorizationStop?: string;
+    authorizationStartTimestamp?: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+declare class EMHCrypt01 extends ACrypt {
+    readonly curve: EllipticCurve;
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IEMHMeasurementValue): Promise<IEMHCrypt01Result>;
+    ViewMeasurement(measurementValue: IEMHMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+    private DecodeStatus;
+}
+
+interface IGDFMeasurementValue extends IMeasurementValue {
+    prevSignature: string;
+}
+interface IGDFCrypt01Result extends ICryptoResult {
+    sha256value?: string;
+    meterId?: string;
+    meter?: IMeter;
+    timestamp?: string;
+    obis?: string;
+    unitEncoded?: string;
+    scale?: string;
+    value?: string;
+    authorizationStart?: string;
+    authorizationStartTimestamp?: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+declare class GDFCrypt01 extends ACrypt {
+    readonly curve: EllipticCurve;
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IGDFMeasurementValue): Promise<IGDFCrypt01Result>;
+    ViewMeasurement(measurementValue: IGDFMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+}
+
+declare const MENNEKES_EDL40_XMLNS = "http://www.mennekes.de/Mennekes.EdlVerification.xsd";
+declare const MENNEKES_EDL40_OBIS = "1-0:1.17.0*255";
+interface IMennekesMeasurement {
+    timestampCustomerIdent?: string;
+    timestamp: string;
+    signature: string;
+    eventCounter: number;
+    meterStatus: number;
+    value: number;
+    scaler: number;
+    pagination: number;
+    secondIndex: number;
+}
+interface IMennekesChargingProcess {
+    serverId: string;
+    publicKey: string;
+    meteringPoint?: string;
+    siteAddress?: IAddress;
+    customerIdent: string;
+    timestampCustomerIdent: string;
+    measurementStart: IMennekesMeasurement;
+    measurementEnd: IMennekesMeasurement;
+}
+interface IMennekesBilling {
+    chargingProcesses: IMennekesChargingProcess[];
+}
+interface IMennekesMeasurementValue extends IMeasurementValue {
+    eventCounter: number;
+    meterStatusNumber: number;
+    originalSignature: string;
+    timestampCustomerIdent?: string;
+    measurement: IMennekesChargyMeasurement;
+}
+interface IMennekesChargyMeasurement extends IMeasurement {
+    serverId: string;
+    publicKey: string;
+    customerIdent: string;
+    timestampCustomerIdent: string;
+    values: IMennekesMeasurementValue[];
+}
+interface IMennekesCrypt01Result extends ICryptoResult {
+    hashValue?: string;
+    signedData?: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    signature?: ISignatureRS;
+    serverId?: string;
+    timestamp?: string;
+    meterStatus?: string;
+    secondsIndex?: string;
+    pagination?: string;
+    obis?: string;
+    unitEncoded?: string;
+    scaler?: string;
+    value?: string;
+    logBytes?: string;
+    customerIdent?: string;
+    timestampCustomerIdent?: string;
+}
+declare class Mennekes {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    tryToParseMennekesXML(XMLDocument: Document): Promise<IChargeTransparencyRecord | ISessionCryptoResult>;
+    private toChargeTransparencyRecord;
+    private toChargingStation;
+    private toChargingSession;
+    private evseId;
+    private meterId;
+}
+declare class MennekesCrypt01 extends ACrypt {
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IMennekesMeasurementValue): Promise<IMennekesCrypt01Result>;
+    ViewMeasurement(measurementValue: IMennekesMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+}
+declare function extractMennekesChargingProcesses(XMLDocument: Document): IMennekesChargingProcess[];
+declare function parseMennekesXMLDocument(XMLDocument: Document): IMennekesBilling | IMennekesChargingProcess;
+declare function buildMennekesSignatureData(chargingProcess: IMennekesChargingProcess, measurement: IMennekesMeasurement): Uint8Array;
+declare function dateToMennekesLocalEpochSeconds(isoTimestamp: string): number;
+declare function cleanHex(hex: string): string;
+declare function hexToBytes(hex: string): Uint8Array;
+declare function bytesToHex(bytes: Uint8Array): string;
+
+interface IOCMFv1_0MeasurementValue extends IOCMFMeasurementValue {
+    statusMeter: string;
+    secondsIndex: number;
+    paginationId: string;
+    logBookIndex: string;
+}
+interface IOCMFv1_0Result extends ICryptoResult {
+    sha256value?: string;
+    meterId?: string;
+    meter?: IMeter;
+    timestamp?: string;
+    infoStatus?: string;
+    secondsIndex?: string;
+    paginationId?: string;
+    obis?: string;
+    unitEncoded?: string;
+    scale?: string;
+    value?: string;
+    logBookIndex?: string;
+    authorizationStart?: string;
+    authorizationStop?: string;
+    authorizationStartTimestamp?: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+declare class OCMFv1_x extends ACrypt {
+    readonly curve: EllipticCurve;
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IOCMFv1_0MeasurementValue): Promise<IOCMFv1_0Result>;
+    private PayloadDictionary;
+    private SignatureDictionary;
+    ViewMeasurement(measurementValue: IOCMFv1_0MeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+}
+declare const enum OCMFTransactionTypes {
+    undefined = "undefined",
+    fiscal = "fiscal",
+    transaction = "transaction"
+}
+declare const enum TimeStatusTypes {
+    unknown = "unknown",
+    informative = "informative",
+    syncronized = "syncronized",
+    relative = "relative"
+}
+interface IOCMFLossCompensation {
+    LN?: string;
+    LI?: string;
+    LR: string;
+    LU: string;
+}
+interface IOCMFReading {
+    TM?: string;
+    TX?: string;
+    RV?: Decimal;
+    RI?: string;
+    RU?: string;
+    RT?: string;
+    CL?: number;
+    EF?: string;
+    ST?: string;
+}
+interface IOCMFSignature {
+    SA?: string;
+    SE?: string;
+    SM?: string;
+    SD: string;
+    A?: unknown;
+    B?: unknown;
+    C?: unknown;
+    D?: unknown;
+    E?: unknown;
+    F?: unknown;
+    U?: unknown;
+    V?: unknown;
+    W?: unknown;
+    X?: unknown;
+    Y?: unknown;
+    Z?: unknown;
+}
+interface IOCMFPayload {
+    FV?: string;
+    GI?: string;
+    VI?: string;
+    GS?: string;
+    GV?: string;
+    VV?: string;
+    PG: string;
+    MV?: string;
+    MM?: string;
+    MS?: string;
+    MF?: string;
+    IS: boolean | string;
+    IL?: string;
+    IF?: string[];
+    IT?: string;
+    ID?: string;
+    TT?: string;
+    CF?: string;
+    LC?: IOCMFLossCompensation;
+    CT?: string;
+    CI?: string;
+    RD: Array<IOCMFReading>;
+    U?: unknown;
+    V?: unknown;
+    W?: unknown;
+    X?: unknown;
+    Y?: unknown;
+    Z?: unknown;
+}
+interface IOCMFJSONDocument {
+    "@context": string | string[];
+    raw?: string;
+    rawPayload?: string;
+    hashAlgorithm: string;
+    hashValue: string;
+    payload: IOCMFPayload;
+    signature: IOCMFSignature;
+    signatureRS?: ISignatureRS;
+    publicKey?: string | IPublicKeyXY;
+    publicKeyEncoding?: string;
+    validationStatus?: VerificationResult;
+}
+interface IOCMFMeasurementValue extends IMeasurementValue {
+    measurement?: IOCMFMeasurement;
+    timeSync: string;
+    transaction?: string;
+    transactionType: OCMFTransactionTypes;
+    pagination: number;
+    errorFlags?: string;
+    cumulatedLoss?: Decimal;
+    status: string;
+    ocmfDocument?: IOCMFJSONDocument;
+}
+interface IOCMFMeasurement extends IMeasurement {
+    currentType?: string;
+    values: Array<IOCMFMeasurementValue>;
+}
+interface IOCMFAuthorization extends IAuthorization {
+    identificationStatus?: boolean | string;
+    identificationLevel?: string;
+    identificationFlags?: Array<string>;
+}
+interface IOCMFChargingSession extends IChargingSession {
+    internalSessionId?: string;
+    authorizationStart: IOCMFAuthorization;
+    meter?: IMeter;
+    measurements: Array<IOCMFMeasurement>;
+}
+interface IOCMFCTRExtensions {
+    formatVersion?: string;
+    gatewayInformation?: string;
+    gatewaySerial?: string;
+    gatewayVersion?: string;
+}
+interface IOCMFChargeTransparencyRecord extends IChargeTransparencyRecord {
+    ocmf?: IOCMFCTRExtensions;
+    chargingSessions?: Array<IOCMFChargingSession>;
+}
+declare class OCMF {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    private tryToParseOCMFv1_0;
+    private mergeOCMFSessions;
+    private mergeChargeTransparencyRecords;
+    private validateOCMFSignature;
+    private parseOCMFJSONDocuments;
+    TryToParseOCMFDocument(OCMFDocument: string, PublicKey?: string | IPublicKeyXY, PublicKeyEncoding?: string, ContainerInfos?: unknown): Promise<IChargeTransparencyRecord | ISessionCryptoResult>;
+    TryToParseOCMFDocuments(OCMFDocuments: string[], PublicKey?: string | IPublicKeyXY, PublicKeyEncoding?: string, ContainerInfos?: unknown): Promise<IChargeTransparencyRecord | ISessionCryptoResult>;
+    private convertToISO8601;
+}
+
+declare class OCPI {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    private bufferToHex;
+    private bufferToNumber;
+    tryToParseOCPIFormat(SomeJSON: unknown): Promise<IChargeTransparencyRecord | ISessionCryptoResult>;
+}
+
+declare const PCDF_PREFIX = "128.8.0";
+declare const PCDF_FIELD_ORDER: readonly ["ST", "CT", "CD", "TV", "BV", "CSC", "SP", "RV", "SI", "CS", "HW", "DT", "PK", "SG"];
+type PCDFFieldKey = typeof PCDF_FIELD_ORDER[number];
+interface IPCDFRawFields extends Record<PCDFFieldKey, string> {
+    ST: string;
+    CT: string;
+    CD: string;
+    TV: string;
+    BV: string;
+    CSC: string;
+    SP: string;
+    RV: string;
+    SI: string;
+    CS: string;
+    HW: string;
+    DT: string;
+    PK: string;
+    SG: string;
+}
+interface IPCDFSessionInfo {
+    idTag: string;
+    idTagType: string;
+    transactionId: string;
+}
+interface IPCDFValidatedData {
+    startTime: string;
+    stopTime: string;
+    durationSeconds: number;
+    timeValid: boolean;
+    billingValid: boolean;
+    chargingSessionCounter: number;
+    stopPresent: boolean;
+    readingValue: Decimal;
+    readingUnit: string;
+    session: IPCDFSessionInfo;
+    softwareChecksum: string;
+    hardwareSerial: string;
+    dcMeterType: number;
+    publicKey: IPublicKeyXY;
+    signature: ISignatureRS;
+}
+interface IPCDFDocument {
+    "@context": "PCDF";
+    raw: string;
+    fields: IPCDFRawFields;
+    signedPayload: string;
+    hashAlgorithm: string;
+    hashValue: string;
+    data: IPCDFValidatedData;
+    publicKeyHex: string;
+    signatureHex: string;
+    validationStatus: VerificationResult;
+}
+interface IPCDFMeasurementValue extends IMeasurementValue {
+    pcdfDocument?: IPCDFDocument;
+}
+interface IPCDFMeasurement extends IMeasurement {
+    values: Array<IPCDFMeasurementValue>;
+}
+interface IPCDFChargingSession extends IChargingSession {
+    measurements: Array<IPCDFMeasurement>;
+}
+interface IPCDFChargeTransparencyRecord extends IChargeTransparencyRecord {
+    pcdf?: {
+        chargingSessionCounter: number;
+        timeValid: boolean;
+        billingValid: boolean;
+        stopPresent: boolean;
+        chargingDuration: number;
+        dcMeterType: number;
+        softwareChecksum: string;
+    };
+    chargingSessions?: Array<IPCDFChargingSession>;
+}
+declare class PCDFParseError extends Error {
+    readonly code: string;
+    readonly field?: PCDFFieldKey | undefined;
+    constructor(code: string, message: string, field?: PCDFFieldKey | undefined);
+}
+declare class PCDFValidationError extends Error {
+    readonly errors: Array<string>;
+    constructor(errors: Array<string>);
+}
+declare function isPCDFText(input: string | undefined): boolean;
+declare function unquotePCDFText(input: string): string;
+declare function stripPCDFControlCharacters(input: string): string;
+declare function parsePCDFDocument(input: string): {
+    raw: string;
+    fields: IPCDFRawFields;
+    signedPayload: string;
+};
+declare function validatePCDFFields(fields: IPCDFRawFields): IPCDFValidatedData;
+declare function normalizePCDFPublicKeyHex(publicKeyHex: string): string;
+declare function parsePCDFPublicKey(publicKeyHex: string): IPublicKeyXY;
+declare function parsePCDFSignature(signatureHex: string): ISignatureRS;
+declare function verifyPCDFDocument(document: IPCDFDocument, chargy: Chargy): Promise<VerificationResult>;
+declare class PCDFCrypt01 extends ACrypt {
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IPCDFMeasurementValue): Promise<ICryptoResult>;
+    ViewMeasurement(measurementValue: IPCDFMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+}
+interface IPCDFCrypt01Result extends ICryptoResult {
+    hashValue?: string;
+    publicKey?: string;
+    signature?: ISignatureRS;
+}
+declare class PCDF {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    TryToParsePCDFDocument(PCDFDocument: string, externalPublicKey?: string): Promise<IPCDFChargeTransparencyRecord | ISessionCryptoResult>;
+    private createChargeTransparencyRecord;
+}
+
+/**
+ * The root element that contains the four rings of the Digital Calibration Certificate (DCC).
+ * @interface IDigitalCalibrationCertificate
+ * @property {AdministrativeDataType} administrativeData - All essential administrative information about the calibration.
+ * @property {Array<MeasurementResultType>} measurementResults - List of measurement results that are part of a DCC.
+ * @property {Array<string>} [comments] - Optional comments about the calibration.
+ * @property {ByteDataType} [document] - Optional binary encoded file of the DCC.
+ * @property {string} schemaVersion - The version of the DCC schema, e.g. "3.2.1"
+ * @property {Array<chargyInterfaces.ISignatureRS>} [signatures] - Optional list of digital signatures.
+ */
+interface IDigitalCalibrationCertificate {
+    "@id": string;
+    "@context"?: string | Array<string>;
+    administrativeData: AdministrativeDataType;
+    measurementResults: Array<MeasurementResultType>;
+    comments?: Array<string>;
+    document?: ByteDataType;
+    schemaVersion: string;
+    signatures?: Array<ISignatureRS>;
+}
+/**
+ * The element administrativeData contains all essential administrative information about the calibration.
+ * The entries in this area are basically the same and regulated in all DCCs.
+ * @interface AdministrativeDataType
+ * @property {Array<SoftwareType>} software - A list of software elements.
+ * @property {Array<RefTypeDefinitionType>} [refTypeDefinitions] - An optional list of information about the used refTypes in a DCC.
+ * @property {CoreDataType} coreData - The core data of the DCC.
+ * @property {Array<ItemType>} items - A list of items that are part of the calibration.
+ * @property {CalibrationLaboratoryType} calibrationLaboratory - Information about the calibration laboratory.
+ * @property {Array<RespPersonType>} respPersons - A list of responsible persons.
+ * @property {ContactType} customer - Information about the customer.
+ * @property {Array<StatementMetaDataType>} [statements] - Optional list of statements.
+ */
+interface AdministrativeDataType {
+    software: Array<SoftwareType>;
+    refTypeDefinitions?: Array<RefTypeDefinitionType>;
+    coreData: CoreDataType;
+    items: Array<ItemType>;
+    calibrationLaboratory: CalibrationLaboratoryType;
+    respPersons: Array<RespPersonType>;
+    customer: ContactType;
+    statements?: Array<StatementMetaDataType>;
+}
+/**
+ * Information about a software including its name, version and a description.
+ * @interface SoftwareType
+ */
+interface SoftwareType {
+    name: IMultilanguageText;
+    release: string;
+    type?: 'application' | 'bios' | 'driver' | 'editor' | 'firmware' | 'library' | 'os' | 'other';
+    description?: RichContentType;
+    id?: string;
+    refType?: string;
+}
+/**
+ * This type contains the information about the wording of the refTypes used in a DCC.
+ * @interface RefTypeDefinitionType
+ */
+interface RefTypeDefinitionType {
+    name: IMultilanguageText;
+    description?: RichContentType;
+    namespace: string;
+    link: string;
+    release?: string;
+    value?: string;
+    procedure?: string;
+    refType?: string;
+}
+interface RichContentType {
+    name?: IMultilanguageText;
+    content?: Array<IDCCStringWithLangType>;
+    file?: Array<ByteDataType>;
+    formula?: Array<FormulaType>;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface IDCCStringWithLangType {
+    value: string;
+    lang?: string;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface FormulaType {
+    latex?: string;
+    mathml?: unknown;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface UsedMethodType {
+    name: IMultilanguageText;
+    description?: RichContentType;
+    norm?: Array<string>;
+    reference?: Array<string>;
+    id?: string;
+    refType?: string;
+}
+interface IdentificationType {
+    issuer: 'manufacturer' | 'calibrationLaboratory' | 'customer' | 'owner' | 'other';
+    value: string;
+    name?: IMultilanguageText;
+    id?: string;
+    refType?: string;
+}
+interface MeasuringEquipmentType {
+    name: IMultilanguageText;
+    equipmentClass?: Array<EquipmentClassType>;
+    description?: RichContentType;
+    certificate?: HashType;
+    manufacturer?: ContactNotStrictType;
+    model?: string;
+    identifications?: Array<IdentificationType>;
+    measuringEquipmentQuantities?: Array<PrimitiveQuantityType>;
+    id?: string;
+    refType?: string;
+}
+interface PrimitiveQuantityType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    noQuantity?: RichContentType;
+    charsXMLList?: Array<string>;
+    real?: unknown;
+    hybrid?: unknown;
+    complex?: unknown;
+    constant?: unknown;
+    realListXMLList?: unknown;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface EquipmentClassType {
+    reference: string;
+    classID: string;
+    id?: string;
+    refType?: string;
+}
+interface HashType {
+    referral: IMultilanguageText;
+    referralID: string;
+    procedure: string;
+    value: string;
+    description?: RichContentType;
+    inValidityRange?: boolean;
+    traceable?: boolean;
+    linkedReport?: HashType;
+    id?: string;
+    refType?: string;
+}
+interface LocationType {
+    city?: string;
+    countryCode?: string;
+    postCode?: string;
+    postOfficeBox?: string;
+    state?: string;
+    street?: string;
+    streetNo?: string;
+    further?: RichContentType;
+    positionCoordinates?: PositionCoordinatesType;
+}
+interface PositionCoordinatesType {
+    positionCoordinateSystem: string;
+    reference?: string;
+    declaration?: RichContentType;
+    positionCoordinate1: RealQuantityType;
+    positionCoordinate2: RealQuantityType;
+    positionCoordinate3?: RealQuantityType;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface RealQuantityType {
+    value: number;
+    uncertainty?: number;
+}
+interface ContactNotStrictType {
+    name: IMultilanguageText;
+    eMail?: string;
+    phone?: string;
+    fax?: string;
+    location?: LocationType;
+    descriptionData?: ByteDataType;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface ResultType {
+    name: IMultilanguageText;
+    description?: RichContentType;
+    data: DataType;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+/**
+ * A measurement results with the methods, software and equipments used for the calibration.
+ * Also contains influence conditions and a list of the actual results.
+ */
+interface MeasurementResultType {
+    name: IMultilanguageText;
+    description?: RichContentType;
+    usedMethods?: Array<UsedMethodType>;
+    usedSoftware?: Array<SoftwareType>;
+    measuringEquipments?: Array<MeasuringEquipmentType>;
+    influenceConditions?: Array<InfluenceConditionType>;
+    results: Array<ResultType>;
+    measurementMetaData?: Array<StatementMetaDataType>;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+/**
+ * The byteDataType defines a type which allows to add binary encoded files to the measurement result section.
+ * @interface ByteDataType
+ */
+interface ByteDataType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    fileName: string;
+    mimeType: string;
+    dataBase64: string;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface XMLType {
+    content: unknown;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface QuantityType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    noQuantity?: RichContentType;
+    charsXMLList?: Array<string>;
+    real?: unknown;
+    hybrid?: unknown;
+    complex?: unknown;
+    constant?: unknown;
+    realListXMLList?: unknown;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface ListType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    dateTime?: Date;
+    dateTimeXMLList?: Array<Date>;
+    quantities?: Array<QuantityType>;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface DataType {
+    text?: Array<RichContentType>;
+    formula?: Array<FormulaType>;
+    byteData?: Array<ByteDataType>;
+    xml?: Array<XMLType>;
+    quantity?: Array<QuantityType>;
+    list?: Array<ListType>;
+    id?: string;
+    refId?: string[];
+    refType?: string;
+}
+interface InfluenceConditionType {
+    name: IMultilanguageText;
+    description?: RichContentType;
+    status?: 'beforeAdjustment' | 'afterAdjustment' | 'beforeRepair' | 'afterRepair';
+    certificate?: HashType;
+    data: DataType;
+    id?: string;
+    refType?: string;
+}
+interface ContactType {
+    name: IMultilanguageText;
+    eMail?: string;
+    phone?: string;
+    fax?: string;
+    location: LocationType;
+    descriptionData?: ByteDataType;
+    id?: string;
+}
+interface ItemType {
+    name: IMultilanguageText;
+    equipmentClass?: EquipmentClassType[];
+    description?: RichContentType;
+    installedSoftwares?: Array<SoftwareType>;
+    manufacturer?: ContactNotStrictType;
+    model?: string;
+    identifications: Array<IdentificationType>;
+    itemQuantities?: Array<PrimitiveQuantityType>;
+    id?: string;
+    refType?: string;
+}
+interface RespPersonType {
+    person: ContactNotStrictType;
+    description?: RichContentType;
+    role?: string;
+    mainSigner?: boolean;
+    cryptElectronicSeal?: boolean;
+    cryptElectronicSignature?: boolean;
+    cryptElectronicTimeStamp?: boolean;
+    id?: string;
+    refType?: string;
+}
+interface PerformanceLocationType {
+    location: 'laboratory' | 'customer' | 'laboratoryBranch' | 'customerBranch' | 'other';
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface ReportAmendedSubstitutedType {
+    typeOfChange: 'amended' | 'substituted';
+    replacedUniqueIdentifier: string;
+    id?: string;
+    refType?: string;
+}
+interface CoreDataType {
+    countryCodeISO3166_1: string;
+    usedLangCodeISO639_1: Array<string>;
+    mandatoryLangCodeISO639_1: Array<string>;
+    uniqueIdentifier: string;
+    identifications?: Array<IdentificationType>;
+    receiptDate?: Date;
+    beginPerformanceDate: Date;
+    endPerformanceDate: Date;
+    performanceLocation: PerformanceLocationType;
+    issueDate?: Date;
+    reportAmendedSubstituted?: ReportAmendedSubstitutedType;
+    previousReport?: HashType;
+}
+interface StatementMetaDataType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    countryCodeISO3166_1?: Array<string>;
+    convention?: string;
+    traceable?: boolean;
+    norm?: Array<string>;
+    reference?: Array<string>;
+    declaration?: RichContentType;
+    valid?: boolean;
+    validXMLList?: Array<boolean>;
+    date?: Date;
+    period?: string;
+    respAuthority?: ContactType;
+    conformity?: string;
+    conformityXMLList?: Array<string>;
+    data?: DataType;
+    nonSIDefinition?: string;
+    nonSIUnit?: string;
+    location?: LocationType;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+interface StatementMetaDataType {
+    name?: IMultilanguageText;
+    description?: RichContentType;
+    countryCodeISO3166_1?: Array<string>;
+    convention?: string;
+    traceable?: boolean;
+    norm?: Array<string>;
+    reference?: Array<string>;
+    declaration?: RichContentType;
+    valid?: boolean;
+    validXMLList?: Array<boolean>;
+    date?: Date;
+    period?: string;
+    respAuthority?: ContactType;
+    conformity?: string;
+    conformityXMLList?: Array<string>;
+    data?: DataType;
+    nonSIDefinition?: string;
+    nonSIUnit?: string;
+    location?: LocationType;
+    id?: string;
+    refId?: Array<string>;
+    refType?: string;
+}
+/**
+ * Information about the calibration laboratory.
+ * @interface CalibrationLaboratoryType
+ * @property {string} [calibrationLaboratoryCode] - Optional code of the calibration laboratory.
+ * @property {ContactType} contact - Contact information about the calibration laboratory.
+ */
+interface CalibrationLaboratoryType {
+    calibrationLaboratoryCode?: string;
+    contact: ContactType;
+    cryptElectronicSeal?: boolean;
+    cryptElectronicSignature?: boolean;
+    cryptElectronicTimeStamp?: boolean;
+}
+
+interface ICertificateOfAccreditation {
+    "@id": string;
+    "@context"?: string | Array<string>;
+    signatures?: Array<ISignatureRS>;
+}
+
+interface IDigitalCertificateOfCompliance {
+    "@id": string;
+    "@context"?: string | Array<string>;
+    signatures?: Array<ISignatureRS>;
+}
+
+interface ISAFEXMLEVSEContext {
+    "@id": string;
+    description?: IMultilanguageText;
+    meters: Array<IMeter>;
+    connector?: IConnector$1 & {
+        "@id"?: string;
+    };
+}
+interface ISAFEXMLChargingStationInfo {
+    "@id": string;
+    description?: IMultilanguageText;
+    firmwareVersion?: string;
+    softwareVersion?: string;
+    geoLocation?: IGeoLocation;
+    EVSE?: ISAFEXMLEVSEContext;
+}
+interface ISAFEXMLChargingStationContext {
+    ChargingStationId?: string;
+    EVSEId?: string;
+    chargingStation?: ISAFEXMLChargingStationInfo;
+    EVSE?: ISAFEXMLEVSEContext;
+    connector?: IConnector$1 & {
+        "@id"?: string;
+    };
+}
+declare class SAFEXML {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    static ParseChargingStationContext(XMLDocument: Document): ISAFEXMLChargingStationContext;
+    tryToParseSAFEXML(XMLDocument: Document): Promise<IChargeTransparencyRecord | ISessionCryptoResult>;
+}
+
+declare class XMLContainer {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    tryToParseXMLContainer(XMLDocument: Document): IChargeTransparencyRecord | ISessionCryptoResult;
+}
+
+declare class ChargeIT {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    private bufferToHex;
+    private bufferToNumber;
+    TryToParseOldChargeITMeterValuesFormat(CTR: IChargeTransparencyRecord, evseId: string, address: JSONObject, geoLocation: JSONObject, signedMeterValues: Array<unknown>): IChargeTransparencyRecord | ISessionCryptoResult;
+    TryToParseChargeITContainerFormat(SomeJSON: unknown): IChargeTransparencyRecord | ISessionCryptoResult;
+}
+
+type IChargepointChargeTransparencyRecord = IChargeTransparencyRecord;
+declare class ChargePoint {
+    private readonly chargy;
+    constructor(chargy: Chargy);
+    TryToParseChargepointFormat(SomeJSON: unknown): IChargeTransparencyRecord | ISessionCryptoResult;
+}
+interface IChargepointMeasurementValue extends IMeasurementValue {
+    statusMeter: string;
+    secondsIndex: number;
+    paginationId: string;
+    logBookIndex: string;
+}
+interface IChargePointCrypt01Result extends ICryptoResult {
+    sha256value?: string;
+    meterId?: string;
+    meter?: IMeter;
+    timestamp?: string;
+    infoStatus?: string;
+    secondsIndex?: string;
+    paginationId?: string;
+    obis?: string;
+    unitEncoded?: string;
+    scale?: string;
+    value?: string;
+    logBookIndex?: string;
+    authorizationStart?: string;
+    authorizationStop?: string;
+    authorizationStartTimestamp?: string;
+    publicKey?: string;
+    publicKeyFormat?: string;
+    publicKeySignatures?: Array<unknown>;
+    signature?: ISignatureRS;
+}
+declare class ChargePointCrypt01 extends ACrypt {
+    constructor(chargy: Chargy);
+    VerifyChargingSession(chargingSession: IChargingSession): Promise<ISessionCryptoResult>;
+    VerifyMeasurement(measurementValue: IChargepointMeasurementValue): Promise<IChargePointCrypt01Result>;
+    ViewMeasurement(measurementValue: IChargepointMeasurementValue, errorDiv: HTMLDivElement, introDiv: HTMLDivElement, infoDiv: HTMLDivElement, PlainTextDiv: HTMLDivElement, HashedPlainTextDiv: HTMLDivElement, PublicKeyDiv: HTMLDivElement, SignatureExpectedDiv: HTMLDivElement, SignatureCheckDiv: HTMLDivElement): Promise<Error | undefined>;
+}
+
+type QRImageData = {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+};
+declare function readQRCodeTextFromImage(data: ArrayBuffer | Uint8Array, mimeType?: string): Promise<string | undefined>;
+declare function readQRCodeTextFromImageData(imageData: QRImageData): string | undefined;
+
+/**
+ * Extracts the per-session verification results from a verified Charge Transparency
+ * Record. When the record carries no usable session results, a single "no charge
+ * transparency records found" result is returned instead.
+ *
+ * This is exactly the payload the renderer hands to the main process (and, in
+ * --nogui / HTTP mode, to the CLI verification service) after a verification. It
+ * is kept here as a pure, DOM-free function so the renderer (ChargyApp), the main
+ * process and the tests can all share the very same logic instead of mirroring it.
+ *
+ * The "no records found" message is passed in so the renderer can localize it,
+ * while non-UI callers (CLI service, tests) get a sensible English default.
+ */
+declare function toSessionVerificationResults(CTR: IChargeTransparencyRecord, noRecordsMessage?: string): ISessionCryptoResult[] | ISessionCryptoResult;
+
+export { ACrypt, type AdministrativeDataType, Alfen, AlfenCrypt01, BSMCrypt01, type ByteDataType, type CalibrationLaboratoryType, CanonicalJSONError, ChargeIT, ChargePoint, ChargePointCrypt01, IChargeTransparencyLiveLink$1 as ChargeTransparencyLiveLink, ChargeTransparencyLiveLinkContext, IChargeTransparencyRecord$1 as ChargeTransparencyRecord, Chargy, chargyInterfaces as ChargyInterfaces, type CheckMeterPublicKeySignatureFunc, Clone, CloneCTR, ConcatenateBuffers, type ContactNotStrictType, type ContactType, type CoreDataType, CreateDiv, CreateDiv2, CryptoAlgorithms, CryptoHashAlgorithms, type DataType, DayOfWeek, DisplayPrefixes, EMHCrypt01, type EllipticCurve, type EllipticKeyPair, type EquipmentClassType, type FormulaType, GDFCrypt01, type GetChargingPoolFunc, type GetChargingStationFunc, type GetEVSEFunc, type GetMeterFunc, type HashType, type I18NDictionary, type IAddress, type IAlfenChargeTransparencyRecord, type IAlfenChargingSession, type IAlfenCrypt01Result, type IAlfenMeasurement, type IAlfenMeasurementValue, type IAuthorization, type IBSMCrypt01Result, type IBSMMeasurementValue, type ICalibration, type ICertificateOfAccreditation, type IChargePointCrypt01Result, type IChargeTransparencyLiveLink, type IChargeTransparencyRecord, type IChargepointChargeTransparencyRecord, type IChargepointMeasurementValue, type IChargingCosts, type IChargingPeriod, type IChargingPool, type IChargingProduct, type IChargingProductRelevance, type IChargingSession, type IChargingStation, type IChargingStationOperator, type IChargingTariff, type IChargingTariffElement, type IConformity, type IConnector$1 as IConnector, type IContact, type IContract, type ICost, type ICryptoHashes, type ICryptoResult, type IDCCStringWithLangType, type IDigitalCalibrationCertificate, type IDigitalCertificateOfCompliance, type IDisplayText, IECCurves, type IEMHCrypt01Result, type IEMHMeasurementValue, type IEMobilityProvider, type IEVSE, IEncoding, type IExtendedFileInfo, type IFileInfo, type IFlatCost, type IGDFCrypt01Result, type IGDFMeasurementValue, type IGeoLocation, type IKeyInfo, type ILegalCompliance, type IMeasurement, type IMeasurementValue, type IMeasurements, type IMediationService, type IMennekesBilling, type IMennekesChargingProcess, type IMennekesChargyMeasurement, type IMennekesCrypt01Result, type IMennekesMeasurement, type IMennekesMeasurementValue, type IMeter, type IMultilanguageText, type IOCMFAuthorization, type IOCMFCTRExtensions, type IOCMFChargeTransparencyRecord, type IOCMFChargingSession, type IOCMFJSONDocument, type IOCMFLossCompensation, type IOCMFMeasurement, type IOCMFMeasurementValue, type IOCMFPayload, type IOCMFReading, type IOCMFSignature, type IOCMFv1_0MeasurementValue, type IOCMFv1_0Result, type IOIDInfo, type IPCDFChargeTransparencyRecord, type IPCDFChargingSession, type IPCDFCrypt01Result, type IPCDFDocument, type IPCDFMeasurement, type IPCDFMeasurementValue, type IPCDFRawFields, type IPCDFSessionInfo, type IPCDFValidatedData, type IParking, type IParkingTariff, type IPriceComponent, type IPrivacy, type IPublicKey, type IPublicKeyInfo, type IPublicKeyLookup, type IPublicKeyXY, type IPublicKeysignature, type IResult, type ISAFEXMLChargingStationContext, type ISAFEXMLChargingStationInfo, type ISAFEXMLEVSEContext, type ISessionCryptoResult, type ISignature, type ISignatureInfos, type ISignatureRS, type ISupport, type ITariffRestriction, type ITaxes, type ITransparencyInfos, type ITransparencySoftware, type ITransport, type ITransportURL, type IVersion, type IVersionPackage, type IVersionSignature, type IVersions, type IdentificationType, type InfluenceConditionType, InformationRelevance, InformationRelevanceToString, IsAChargeTransparencyLiveLink, IsAChargeTransparencyRecord, IsAPublicKeyInfo, IsAPublicKeyLookup, IsASessionCryptoResult, IsNullOrEmpty, type IssueReportPayload, type ItemType, type JSONLDObject, type JSONMessage, type JSONMessageSignaturesVerificationResult, type JSONObject, type JSONSignature, type JSONSignatureVerificationResult, JSONSignatureVerificationStatus, type ListType, type LocationType, MENNEKES_EDL40_OBIS, MENNEKES_EDL40_XMLNS, type MeasurementResultType, type MeasuringEquipmentType, Mennekes, MennekesCrypt01, OBIS2Hex, OBIS2MeasurementName, OBIS_RegExpr, OCMF, OCMFTransactionTypes, OCMFv1_x, OCPI, PCDF, PCDFCrypt01, type PCDFFieldKey, PCDFParseError, PCDFValidationError, PCDF_FIELD_ORDER, PCDF_PREFIX, ParseJSON_LD, type PerformanceLocationType, type PositionCoordinatesType, type PrimitiveQuantityType, PublicKeyFormats, IPublicKeyInfo$1 as PublicKeyInfo, type QuantityType, type RealQuantityType, type RefTypeDefinitionType, type ReportAmendedSubstitutedType, type RespPersonType, type ResultType, type RichContentType, SAFEXML, SessionVerificationResult, SetHex, SetInt8, SetText, SetText_withLength, SetTimestamp, SetTimestamp32, SetUInt32, SetUInt32_withCode, SetUInt64, SetUInt64D, type ShowPKIDetailsFunction, type SignJSONMessageOptions, SignMessage, SignatureFormats, type SignedJSONMessage, type SoftwareType, type StatementMetaDataType, type String, type TOTPConfig, type TarInfo, TimeStatusTypes, type Transport, type TransportHTTPS, type TransportHTTPSSE, type TransportWebsocket, UTC2human, type UsedMethodType, VerificationResult, VerifyJSONMessageSignatures, WhenNullOrEmpty, XMLContainer, type XMLType, asJSONArray, asJSONObject, asNumber, asString, buf2hex, buildMennekesSignatureData, bytesToHex, canonicalJSONBytes, canonicalJSONStringify, cleanHex, closeFullscreen, createHexString, dateToMennekesLocalEpochSeconds, extractMennekesChargingProcesses, firstKey, firstValue, getDirectChildByLocalName, getDirectChildrenByLocalName, getElementsByLocalName, getInt16Bytes, getInt32Bytes, getInt64Bytes, getInt8Bytes, getTrimmedTextContent, hashFile, hex2bin, hex32, hexToArrayBuffer, hexToBytes, intFromBytes, isGeoLocation, isICryptoResult, isIFileInfo, isIPublicKeyXY, isISessionCryptoResult1, isISessionCryptoResult2, isJSONLDObject, isMandatoryArrayOfStrings, isMandatoryBoolean, isMandatoryDecimal, isMandatoryJSONArray, isMandatoryJSONObject, isMandatoryNumber, isMandatoryString, isMandatoryURL, isMultilanguageText, isOIDInfo, isObject, isOptionalArrayOfStrings, isOptionalDecimal, isOptionalJSONArray, isOptionalJSONArrayError, isOptionalJSONArrayOk, isOptionalJSONObject, isOptionalNumber, isOptionalString, isOptionalURL, isPCDFText, isString, isStringArray, isStringOrOIDInfo, isStringOrStringArray, jsonPrettyPrinter, measurementName2human, normalizePCDFPublicKeyHex, normalizeXMLText, openFullscreen, pad, parseAndVerifyJSONSignatures, parseDescription, parseHexString, parseMennekesXMLDocument, parseNumber, parseOBIS, parsePCDFDocument, parsePCDFPublicKey, parsePCDFSignature, parseUTC, readQRCodeTextFromImage, readQRCodeTextFromImageData, secp224k1, setUILocale, sha256, sha384, sha512, signJSONMessage, signMessage, stripPCDFControlCharacters, time2human, toArrayBuffer, toSessionVerificationResults, toUint8Array, unquotePCDFText, validatePCDFFields, verifyJSONMessageSignatureResults, verifyJSONMessageSignatures, verifyJSONSignature, verifyJSONSignatureResult, verifyPCDFDocument };