@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/calconnect/index.d.ts

@@ -0,0 +1,21 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { PubidDate } from "../../model/component.js";
+export declare const calconnectGrammar: Grammar;
+declare class CalconnectUrnGenerator extends BaseUrnGenerator<CalconnectIdentifier> {
+    generate(): string;
+}
+export declare class CalconnectIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof CalconnectUrnGenerator;
+    readonly series: string | undefined;
+    readonly number: string;
+    readonly date: PubidDate | undefined;
+    render(): string;
+}
+export declare function calconnectGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/calconnect/index.js

@@ -0,0 +1,113 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { BaseBuilder } from "../../model/builder.js";
+import { PubidDate } from "../../model/component.js";
+/**
+ * Port of lib/pubid/calconnect/ on the unified model — the flavor that
+ * motivated it. Shape: CC[/<series>] <number>[:<date>]. The publication
+ * date is a PubidDate serialized FLAT as year/month/day through three
+ * converter mappings (Ruby's `map "year", with: {to: :year_to_kv}` trio);
+ * a partial (date-less) reference simply has no date attribute. URN:
+ * urn:calconnect[:<series>]:<number>[:<full date>].
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const series = match("[A-Za-z]").repeat(1, Infinity).as("series");
+    rule("series", () => series);
+    rule("number", () => digits.then(str(".").or(str("-")).then(digits).maybe()).as("number"));
+    rule("date", () => digits.as("year").then(str("-").then(digits.as("month"), str("-"), digits.as("day")).maybe()));
+    rule("identifier", () => str("CC")
+        .then(str("/").then(series).maybe())
+        .then(str(" "), rules["number"])
+        .then(str(":").then(rules["date"]).maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const calconnectGrammar = { rules: buildRules(), root: "root" };
+class CalconnectUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "calconnect"];
+        if (id.series !== undefined)
+            parts.push(id.series);
+        parts.push(id.number);
+        const date = id.date?.render();
+        if (date !== undefined && date !== "")
+            parts.push(date);
+        return parts.join(":");
+    }
+}
+export class CalconnectIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:calconnect:standard";
+    static attributes = extendAttributes(BaseIdentifier, {
+        series: { type: "string" },
+        number: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "series", to: "series" }, { wire: "number", to: "number" }, {
+        wire: "year",
+        to: "date",
+        toWire: (m) => m["date"]?.year,
+        fromWire: (h) => h["year"] === undefined || h["year"] === null
+            ? undefined
+            : new PubidDate({
+                year: String(h["year"]),
+                month: h["month"],
+                day: h["day"],
+            }),
+    }, { wire: "month", to: "date", toWire: (m) => m["date"]?.month, fromWire: () => undefined }, { wire: "day", to: "date", toWire: (m) => m["date"]?.day, fromWire: () => undefined });
+    static urnGenerator = CalconnectUrnGenerator;
+    render() {
+        const prefix = this.series === undefined ? "CC " : `CC/${this.series} `;
+        const date = this.date?.render();
+        return `${prefix}${this.number}${date === undefined || date === "" ? "" : `:${date}`}`;
+    }
+}
+registerType(CalconnectIdentifier);
+class CalconnectBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return CalconnectIdentifier;
+    }
+    cast(key, value) {
+        // The date needs year+month+day combined; assembled in build().
+        if (key === "year" || key === "month" || key === "day")
+            return null;
+        return value;
+    }
+    build(data) {
+        const flat = Array.isArray(data) ? Object.assign({}, ...data) : data;
+        const attrs = {};
+        if (flat["series"] !== undefined && flat["series"] !== null)
+            attrs["series"] = String(flat["series"]);
+        if (flat["number"] === undefined || flat["number"] === null) {
+            throw new ParseFailed("CalConnect: no number", 0);
+        }
+        attrs["number"] = String(flat["number"]);
+        if (flat["year"] !== undefined && flat["year"] !== null) {
+            attrs["date"] = new PubidDate({
+                year: String(flat["year"]),
+                month: flat["month"] === undefined || flat["month"] === null ? undefined : String(flat["month"]),
+                day: flat["day"] === undefined || flat["day"] === null ? undefined : String(flat["day"]),
+            });
+        }
+        return new CalconnectIdentifier(attrs);
+    }
+}
+export function calconnectGrammarImplementation() {
+    const builder = new CalconnectBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(calconnectGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("CalConnect: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

package/dist/flavors/cen_cenelec/grammar.d.ts

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const cenCenelecGrammar: Grammar;
+/** Parser.parse normalization (parser.rb self.parse). */
+export declare function preprocessCenCenelec(input: string): string;

package/dist/flavors/cen_cenelec/grammar.js

@@ -0,0 +1,107 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/cen_cenelec/parser.rb — 1:1. Root alternation:
+ * fragment_identifier | (stage_prefix|publisher) adopted? type? number
+ * supplements? edition?.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digit = match("[0-9]");
+    const digits = digit.repeat(1, Infinity);
+    const space = str(" ");
+    const dash = str("-");
+    const slash = str("/");
+    const plus = str("+");
+    const colon = str(":");
+    const anyChar = match("[\\s\\S]");
+    const publisherToken = (name) => str(name);
+    rule("publisher", () => publisherToken("CWA").or(publisherToken("HD"), publisherToken("ES"), publisherToken("CR"), publisherToken("ENV")).as("publisher")
+        .or(publisherToken("EN").as("publisher").then(slash.then(publisherToken("CLC").as("copublisher")).maybe()))
+        .or(publisherToken("CEN").as("publisher").then(slash.then(publisherToken("CLC").as("copublisher")).maybe()))
+        .or(publisherToken("CLC").as("publisher").then(slash.then(publisherToken("CEN").as("copublisher")).maybe()))
+        .or(publisherToken("EN").as("publisher")));
+    rule("stage_prefix", () => str("FprEN").or(str("prEN")).as("type_with_stage"));
+    rule("type", () => str("Guide").or(str("GUIDE"), str("TR"), str("TS")).as("type"));
+    rule("number", () => digits.as("number"));
+    rule("part", () => dash.then(match("[0-9-]").repeat(1, Infinity).as("part")));
+    rule("parts", () => ref(rules, "part").repeat(0, Infinity).as("parts"));
+    rule("year", () => colon.then(digit.repeat(4, 4).as("year")));
+    rule("month_digits", () => str("01").or(str("02"), str("03"), str("04"), str("05"), str("06"), str("07"), str("08"), str("09"), str("10"), str("11"), str("12")).as("month"));
+    rule("year_with_month", () => colon.then(digit.repeat(4, 4).as("year")).then(dash).then(ref(rules, "month_digits")));
+    rule("date", () => ref(rules, "year_with_month").or(ref(rules, "year")));
+    rule("amendment", () => plus.as("amd_sep_plus").or(slash.as("amd_sep_slash"))
+        .then(str("A"))
+        .then(digits.as("amd_number"))
+        .then(colon.then(digit.repeat(4, 4).as("amd_year")).maybe()));
+    rule("corrigendum", () => plus.as("amd_sep_plus").or(slash.as("amd_sep_slash"))
+        .then(str("AC"))
+        .then(digits.maybe().as("cor_number"))
+        .then(ref(rules, "year_with_month")
+        .or(colon.then(digit.repeat(4, 4).as("year")))
+        .maybe()));
+    rule("supplement", () => ref(rules, "amendment").or(ref(rules, "corrigendum")).as("supplement"));
+    rule("supplements", () => ref(rules, "supplement").repeat(0, Infinity).as("supplements"));
+    rule("edition", () => space.then(str("ED")).then(digits.as("edition")));
+    rule("fragment_identifier", () => 
+    // Spelled-out keyword form: EN 60038 AMD1 FRAG2.
+    ref(rules, "stage_prefix").or(ref(rules, "publisher"))
+        .then(space)
+        .then(ref(rules, "number"))
+        .then(ref(rules, "parts"))
+        .then(space)
+        .then(str("AMD"))
+        .then(digits.as("amendment_number"))
+        .then(space)
+        .then(str("FRAG"))
+        .then(digits.as("fragment_number"))
+        .or(
+    // Compact supplement notation: the base may carry a year, the
+    // amendment uses the /A1 or +A1 join (with an optional year of
+    // its own) instead of the spelled-out keyword.
+    ref(rules, "stage_prefix").or(ref(rules, "publisher"))
+        .then(space)
+        .then(ref(rules, "number"))
+        .then(ref(rules, "parts"))
+        .then((ref(rules, "year")).maybe())
+        .then(str("/").or(str("+")))
+        .then(str("A"))
+        .then(digits.as("amendment_number"))
+        .then((str(":").then(digits.as("amendment_year"))).maybe())
+        .then(space)
+        .then(str("FRAG"))
+        .then(digits.as("fragment_number"))));
+    rule("adopted_org_prefix", () => str("ISO").or(str("IEC"), str("CISPR")));
+    rule("adopted_string", () => ref(rules, "adopted_org_prefix")
+        .then(ref(rules, "supplement").absent()
+        .then(ref(rules, "edition").absent())
+        .then(anyChar)
+        .repeat(0, Infinity))
+        .as("adopted_string"));
+    rule("identifier", () => ref(rules, "fragment_identifier").or(ref(rules, "stage_prefix").or(ref(rules, "publisher"))
+        .then(space.then(ref(rules, "adopted_string")).maybe())
+        .then(space.then(ref(rules, "type")).or(slash.then(ref(rules, "type"))).maybe())
+        .then(space.then(ref(rules, "number")).then(ref(rules, "parts"))
+        .then(ref(rules, "year").maybe())
+        .maybe())
+        .then(ref(rules, "supplements"))
+        .then(ref(rules, "edition").maybe())));
+    return rules;
+}
+export const cenCenelecGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};
+/** Parser.parse normalization (parser.rb self.parse). */
+export function preprocessCenCenelec(input) {
+    let normalized = input.replace(/[‑­]/g, "-");
+    normalized = normalized.replace(/#.*$/, "").trim();
+    normalized = normalized.replace(/\s*\([^)]*corrigendum[^)]*\)/i, "");
+    normalized = normalized
+        .replaceAll("CEN-CLC", "CEN/CLC")
+        .replaceAll("CLC-CEN", "CLC/CEN")
+        .replaceAll("GUIDE", "Guide");
+    return normalized;
+}

package/dist/flavors/cen_cenelec/index.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from "../../grammar/engine.js";
+import type { FlavorImplementation, Identifier } from "../../conformance/implementation.js";
+/** The tree → identifier pipeline, shared with composed flavors (evs). */
+export declare function buildCenIdentifier(tree: Tree): Identifier;
+export declare function cenCenelecGrammarImplementation(): FlavorImplementation;

package/dist/flavors/cen_cenelec/index.js

@@ -0,0 +1,263 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { grammarImplementation } from "../index.js";
+import { cenCenelecGrammar, preprocessCenCenelec } from "./grammar.js";
+import { AdoptedEuropeanNormClass, AmendmentClass, CEN_DOCUMENT_CLASSES, ConsolidatedIdentifierClass, CorrigendumClass, DEFAULT_TYPED_STAGE, EuropeanPrestandardClass, FragmentClass, PUBLISHER_TYPES, locateStage, locateTypeClass, } from "./model.js";
+/**
+ * Port of lib/pubid/cen_cenelec/builder.rb — the parse-tree → identifier
+ * pipeline: base document (adopted / ENV adoption / implicit IEC adoption /
+ * plain), then the supplement wrapping (slash → standalone, plus →
+ * consolidated) and the fragment path.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const s = String(v);
+    return s.length > 0 ? s : undefined;
+};
+const presentString = (v) => {
+    const s = str(v);
+    return s === undefined || s === "" ? undefined : s;
+};
+function flattenArray(data) {
+    return Object.assign({}, ...data);
+}
+class CenBuilder {
+    build(data) {
+        const d = Array.isArray(data) ? flattenArray(data) : data;
+        if (d["fragment_number"] !== undefined) {
+            return this.buildFragmentIdentifier(d);
+        }
+        const base = this.buildBaseDocument(d);
+        if (this.hasSlashSupplements(d)) {
+            return this.buildStandaloneSupplement(base, d);
+        }
+        const supplementsData = this.extractSupplements(d);
+        if (supplementsData.length > 0) {
+            return this.wrapWithConsolidated(base, supplementsData);
+        }
+        return base;
+    }
+    buildBaseDocument(d) {
+        if (d["adopted_string"] !== undefined) {
+            if (str(d["publisher"]) === "ENV") {
+                return this.buildEnvAdoptedIdentifier(d);
+            }
+            return this.buildAdoptedIdentifier(d);
+        }
+        if (str(d["publisher"]) === "EN" &&
+            (Array.isArray(d["parts"]) ? d["parts"].length === 0 : true) &&
+            !this.hasSupplements(d)) {
+            const adopted = this.buildImplicitAdoption(d);
+            if (adopted !== undefined)
+                return adopted;
+        }
+        const baseData = { ...d };
+        delete baseData["supplements"];
+        return this.buildPlainIdentifier(baseData);
+    }
+    hasSupplements(d) {
+        return this.hasSlashSupplements(d) || this.extractSupplements(d).length > 0;
+    }
+    buildPlainIdentifier(baseData) {
+        const klass = this.locateIdentifierKlass(baseData);
+        const attrs = this.assignAttributes(baseData);
+        return new klass(attrs);
+    }
+    locateIdentifierKlass(d) {
+        if (d["adopted_string"] !== undefined)
+            return AdoptedEuropeanNormClass;
+        const publisherStr = str(d["publisher"]) ?? "";
+        if (PUBLISHER_TYPES.includes(publisherStr)) {
+            const typedStage = locateStage(publisherStr);
+            if (typedStage !== undefined) {
+                const kind = locateTypeClass(typedStage.type_code);
+                if (kind !== undefined)
+                    return CEN_DOCUMENT_CLASSES.get(kind);
+            }
+        }
+        const typeOrStage = str(d["type_with_stage"]) ?? str(d["type"]) ?? str(d["stage"]) ?? "";
+        const typedStage = locateStage(typeOrStage) ?? DEFAULT_TYPED_STAGE;
+        return CEN_DOCUMENT_CLASSES.get(locateTypeClass(typedStage.type_code) ?? "en");
+    }
+    assignAttributes(baseData) {
+        const attrs = {};
+        if (baseData["type_with_stage"] !== undefined) {
+            const typedStage = locateStage(str(baseData["type_with_stage"]) ?? "") ?? DEFAULT_TYPED_STAGE;
+            attrs["typedStage"] = typedStage;
+            attrs["type"] = typedStage.type_code === "en" ? "EN" : typedStage.abbr;
+        }
+        if (baseData["type"] !== undefined) {
+            attrs["type"] = str(baseData["type"]);
+        }
+        if (baseData["publisher"] !== undefined) {
+            attrs["publisher"] = str(baseData["publisher"]);
+        }
+        if (baseData["copublisher"] !== undefined) {
+            attrs["copublishers"] = [str(baseData["copublisher"])];
+        }
+        if (baseData["number"] !== undefined) {
+            attrs["number"] = str(baseData["number"]);
+        }
+        if (Array.isArray(baseData["parts"]) && baseData["parts"].length > 0) {
+            const first = baseData["parts"][0];
+            attrs["part"] = isObj(first) ? str(first["part"]) : str(first);
+        }
+        const year = str(baseData["year"]);
+        if (year !== undefined) {
+            const month = str(baseData["month"]);
+            attrs["date"] = new PubidDateRef(month !== undefined ? { year, month } : { year });
+        }
+        return attrs;
+    }
+    parseAdoptedString(adoptedStr) {
+        if (adoptedStr.startsWith("ISO/IEC") || adoptedStr.includes("ISO/IEC") || adoptedStr.startsWith("ISO")) {
+            const impl = grammarImplementation("iso");
+            if (impl === undefined)
+                throw new Error("iso implementation unavailable");
+            return impl.parse(adoptedStr);
+        }
+        if (adoptedStr.startsWith("IEC")) {
+            const impl = grammarImplementation("iec");
+            if (impl === undefined)
+                throw new Error("iec implementation unavailable");
+            return impl.parse(adoptedStr);
+        }
+        return undefined;
+    }
+    buildAdoptedIdentifier(d) {
+        const adoptedStr = str(d["adopted_string"])?.trim();
+        const adoptedId = adoptedStr !== undefined ? this.parseAdoptedString(adoptedStr) : undefined;
+        const copublishers = Array.isArray(d["copublishers"])
+            ? d["copublishers"].map((c) => str(c["copublisher"]))
+            : d["copublisher"] !== undefined
+                ? [str(d["copublisher"])]
+                : [];
+        const attrs = { adopted: adoptedId };
+        if (d["type_with_stage"] !== undefined) {
+            const typedStage = locateStage(str(d["type_with_stage"]) ?? "") ?? DEFAULT_TYPED_STAGE;
+            attrs["typedStage"] = typedStage;
+            attrs["type"] = "EN";
+        }
+        if (d["publisher"] !== undefined) {
+            attrs["publisher"] = str(d["publisher"]);
+        }
+        if (copublishers.length > 0) {
+            attrs["copublishers"] = copublishers.filter((c) => c !== undefined);
+        }
+        return new AdoptedEuropeanNormClass(attrs);
+    }
+    buildEnvAdoptedIdentifier(d) {
+        const adoptedStr = str(d["adopted_string"])?.trim();
+        const adoptedId = adoptedStr !== undefined ? this.parseAdoptedString(adoptedStr) : undefined;
+        return new EuropeanPrestandardClass({
+            publisher: "ENV",
+            adopted: adoptedId,
+        });
+    }
+    buildImplicitAdoption(d) {
+        const numStr = (str(d["number"]) ?? "").trim();
+        if (!/^\d{1,6}$/.test(numStr))
+            return undefined;
+        const num = Number.parseInt(numStr, 10);
+        if (!(num >= 60000 && num <= 79999))
+            return undefined;
+        const impl = grammarImplementation("iec");
+        if (impl === undefined)
+            return undefined;
+        return new AdoptedEuropeanNormClass({
+            publisher: "EN",
+            adopted: impl.parse(`IEC ${numStr}`),
+        });
+    }
+    buildFragmentIdentifier(d) {
+        const baseData = { ...d };
+        delete baseData["amendment_number"];
+        delete baseData["fragment_number"];
+        delete baseData["amendment_year"];
+        const base = this.buildPlainIdentifier(baseData);
+        // The compact spelling can carry the amendment's own year
+        // (EN 60038/A1:2009 FRAG2); the AMD-keyword spelling cannot.
+        const amendment = new AmendmentClass({
+            base,
+            number: str(d["amendment_number"]),
+            ...(str(d["amendment_year"]) !== undefined ? { year: str(d["amendment_year"]) } : {}),
+        });
+        return new FragmentClass({
+            base: amendment,
+            number: str(d["fragment_number"]),
+        });
+    }
+    supplementDataOf(s) {
+        if (isObj(s) && s["supplement"] !== undefined)
+            return s["supplement"];
+        return s;
+    }
+    extractSupplements(d) {
+        const supps = d["supplements"];
+        if (!Array.isArray(supps) || supps.length === 0)
+            return [];
+        return supps
+            .map((s) => this.supplementDataOf(s))
+            .filter((suppData) => suppData["amd_sep_plus"] !== undefined)
+            .map((suppData) => ({
+            type: (suppData["amd_number"] !== undefined ? "amendment" : "corrigendum"),
+            number: str(suppData["amd_number"]) ?? str(suppData["cor_number"]),
+            year: str(suppData["amd_year"]) ?? str(suppData["year"]),
+            month: str(suppData["month"]),
+        }));
+    }
+    hasSlashSupplements(d) {
+        const supps = d["supplements"];
+        if (!Array.isArray(supps) || supps.length === 0)
+            return false;
+        return supps.some((s) => this.supplementDataOf(s)["amd_sep_slash"] !== undefined);
+    }
+    buildStandaloneSupplement(base, d) {
+        const supps = d["supplements"];
+        const suppData = this.supplementDataOf(supps[0]);
+        if (suppData["amd_number"] !== undefined) {
+            return new AmendmentClass({
+                base,
+                number: str(suppData["amd_number"]),
+                year: presentString(suppData["amd_year"]),
+            });
+        }
+        return new CorrigendumClass({
+            base,
+            number: presentString(suppData["cor_number"]),
+            year: presentString(suppData["year"]),
+            month: presentString(suppData["month"]),
+        });
+    }
+    wrapWithConsolidated(base, supplementsData) {
+        const supplementIds = supplementsData.map((supp) => supp.type === "amendment"
+            ? new AmendmentClass({
+                number: presentString(supp.number),
+                year: presentString(supp.year),
+            })
+            : new CorrigendumClass({
+                number: presentString(supp.number),
+                year: presentString(supp.year),
+                month: presentString(supp.month),
+            }));
+        return new ConsolidatedIdentifierClass({
+            identifiers: [base, ...supplementIds],
+        });
+    }
+}
+import { PubidDate as PubidDateRef } from "../../model/component.js";
+/** The tree → identifier pipeline, shared with composed flavors (evs). */
+export function buildCenIdentifier(tree) {
+    return new CenBuilder().build(tree);
+}
+export function cenCenelecGrammarImplementation() {
+    const builder = new CenBuilder();
+    return {
+        parse(input) {
+            const cleaned = preprocessCenCenelec(input);
+            const tree = parseGrammar(cenCenelecGrammar, cleaned);
+            return builder.build(tree);
+        },
+    };
+}

package/dist/flavors/cen_cenelec/model.d.ts

@@ -0,0 +1,45 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { PubidDate } from "../../model/component.js";
+/**
+ * Port of lib/pubid/cen_cenelec: the flat wire shape (publisher and
+ * copublishers as bare strings, a supplement's number/year/month on the
+ * same keys as a document, a draft stage as one code), the class family
+ * (documents, supplements, consolidated, adopted) and the renderer/URN.
+ */
+export interface CenTypedStage {
+    code: string;
+    stage_code: string;
+    type_code: string;
+    abbr: string;
+}
+export declare const TYPED_STAGES: CenTypedStage[];
+export declare const DEFAULT_TYPED_STAGE: CenTypedStage;
+export declare function locateStage(abbr: string): CenTypedStage | undefined;
+export declare function locateStageByCode(code: string): CenTypedStage | undefined;
+export declare const PUBLISHER_TYPES: string[];
+export type TypeKey = "en" | "ts" | "tr" | "guide" | "cwa" | "hd" | "es" | "cr" | "env";
+export declare function locateTypeClass(typeCode: string): TypeKey | undefined;
+export declare abstract class CenIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    readonly date: PubidDate | undefined;
+    readonly typedStage: CenTypedStage | undefined;
+    readonly type: string | undefined;
+    readonly publisher: string | undefined;
+    readonly copublishers: string[] | undefined;
+    root(): CenIdentifier;
+    toUrn(): string;
+}
+export declare const CEN_DOCUMENT_CLASSES: Map<string, IdentifierStatic>;
+export declare const CenelecHarmonizationDocumentClass: IdentifierStatic;
+export declare const AmendmentClass: IdentifierStatic;
+export declare const CorrigendumClass: IdentifierStatic;
+export declare const FragmentClass: IdentifierStatic;
+export declare const ConsolidatedIdentifierClass: IdentifierStatic;
+export declare const AdoptedEuropeanNormClass: IdentifierStatic;
+export declare const EuropeanPrestandardClass: IdentifierStatic;
+export declare const EuropeanNormClass: IdentifierStatic;