@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/asme/index.js

@@ -0,0 +1,138 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { asmeGrammar } from "./grammar.js";
+import { AsmeIdentifier } from "./model.js";
+/**
+ * Port of lib/pubid/asme/builder.rb — joint publishers, BPVC code
+ * assembly, and the flat attribute assignments.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const strv = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    if (Array.isArray(v)) {
+        const flat = v.flat(10);
+        const joined = flat.map(String).join("");
+        return joined.length > 0 ? joined : undefined;
+    }
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function buildCode(parsed) {
+    const designator = parsed["designator"];
+    if (isObj(designator)) {
+        const bpvc = designator["bpvc_code"];
+        if (isObj(bpvc)) {
+            if (bpvc["special"] !== undefined)
+                return "BPVC COMPLETE CODE BIND";
+            const subdivision = isObj(bpvc["subdivision"]) ? bpvc["subdivision"] : undefined;
+            if (subdivision !== undefined && subdivision["ssc_code"] !== undefined) {
+                // BPVC.SSC.XI.II.V.IX pattern. The sections sit under
+                // `ssc_code`; a bare "BPVC.SSC." parses with no inner capture,
+                // so `ssc_code` is the matched string.
+                const sscCode = subdivision["ssc_code"];
+                const sections = isObj(sscCode) ? sscCode["ssc_sections"] : undefined;
+                const sectionsStr = Array.isArray(sections)
+                    ? sections.flat(10).map(String).join(".")
+                    : String(sections ?? "");
+                return sectionsStr === "" ? "BPVC.SSC." : `BPVC.SSC.${sectionsStr}`;
+            }
+            if (subdivision !== undefined && subdivision["case_code"] !== undefined) {
+                const cc = strv(subdivision["case_code"]) ?? "";
+                const caseSub = strv(subdivision["case_sub"]);
+                return caseSub !== undefined && caseSub !== ""
+                    ? `BPVC.CC.${cc}.${caseSub}`
+                    : `BPVC.CC.${cc}`;
+            }
+            if (bpvc["case_code"] !== undefined) {
+                return `BPVC-CC-${strv(bpvc["case_code"])}`;
+            }
+            if (subdivision !== undefined) {
+                const parts = [strv(subdivision["section"]), strv(subdivision["subsection"]), strv(subdivision["sub_subsection"])]
+                    .filter((p) => p !== undefined && p !== "");
+                const langSuffix = strv(subdivision["lang_suffix"]);
+                let result = `BPVC.${parts.join(".")}`;
+                if (langSuffix !== undefined)
+                    result += `_${langSuffix}`;
+                return result;
+            }
+            return "BPVC";
+        }
+    }
+    let designatorStr = isObj(designator) ? strv(designator["designator"]) : strv(designator);
+    designatorStr ??= "";
+    // Normalize "V V" to "V&V".
+    if (designatorStr === "V V")
+        designatorStr = "V&V";
+    const number = strv(parsed["number"]) ?? "";
+    return `${designatorStr}${number}`;
+}
+export function buildAsmeIdentifier(tree) {
+    const parsed = flatten(tree);
+    const self = {};
+    if (parsed["joint_publisher"] !== undefined) {
+        const joint = strv(parsed["joint_publisher"]);
+        self["joint_publisher"] = joint;
+        self["publisher"] = joint;
+    }
+    else if (parsed["first_publisher"] !== undefined) {
+        self["first_publisher"] = strv(parsed["first_publisher"]);
+        self["first_code"] = strv(parsed["first_code"]);
+        self["second_publisher"] = strv(parsed["second_publisher"]);
+        self["publisher"] = `${strv(parsed["first_publisher"])}/${strv(parsed["second_publisher"])}`;
+    }
+    else {
+        self["publisher"] = "ASME";
+    }
+    if (parsed["designator"] !== undefined) {
+        self["number"] = buildCode(parsed);
+    }
+    else if (parsed["number"] !== undefined) {
+        self["number"] = strv(parsed["number"]);
+    }
+    if (parsed["ptc_suffix"] !== undefined)
+        self["ptc_suffix"] = strv(parsed["ptc_suffix"]);
+    if (parsed["year"] !== undefined)
+        self["year"] = strv(parsed["year"]);
+    if (parsed["draft_year"] !== undefined)
+        self["draft_year"] = strv(parsed["draft_year"]);
+    if (parsed["reaffirmation"] !== undefined) {
+        const raw = parsed["reaffirmation"];
+        const reaffirmation = isObj(raw) ? strv(raw["year"]) : strv(raw);
+        self["reaffirmation"] = `R${reaffirmation}`;
+    }
+    if (parsed["language"] !== undefined) {
+        self["language"] = strv(parsed["language"]);
+    }
+    else if (parsed["lang_suffix"] !== undefined) {
+        self["language"] = strv(parsed["lang_suffix"]);
+    }
+    if (parsed["csa_number"] !== undefined)
+        self["csa_number"] = strv(parsed["csa_number"]);
+    if (parsed["handbook"] !== undefined)
+        self["handbook"] = true;
+    if (parsed["revision_note"] !== undefined) {
+        self["revision_note"] = `[${strv(parsed["revision_note"])}]`;
+    }
+    if (parsed["ref_standard"] !== undefined) {
+        const ref = strv(parsed["ref_standard"]) ?? "";
+        const m = /^(Proposed revision|Revision) of (.+)$/.exec(ref);
+        if (m !== null) {
+            self["parenthetical_revision"] = `(${m[1]} of ${m[2]})`;
+        }
+        else {
+            self["parenthetical_revision"] = `(Revision of ${ref})`;
+        }
+    }
+    return new AsmeIdentifier(self);
+}
+export function asmeGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(asmeGrammar, input);
+            return buildAsmeIdentifier(tree);
+        },
+    };
+}

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

@@ -0,0 +1,34 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/asme: the single Standard class (the whole printed
+ * code as `number`), the renderer and the URN generator.
+ */
+declare class AsmeUrnGenerator extends BaseUrnGenerator<AsmeIdentifier> {
+    generate(): string;
+    private specialType;
+}
+export declare class AsmeIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AsmeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly publisher: string | undefined;
+    readonly number: string | undefined;
+    readonly year: string | undefined;
+    readonly reaffirmation: string | undefined;
+    readonly language: string | undefined;
+    readonly csa_number: string | undefined;
+    readonly draft_year: string | undefined;
+    readonly revision_note: string | undefined;
+    readonly parenthetical_revision: string | undefined;
+    readonly handbook: boolean | undefined;
+    readonly ptc_suffix: string | undefined;
+    readonly joint_publisher: string | undefined;
+    readonly first_publisher: string | undefined;
+    readonly first_code: string | undefined;
+    readonly second_publisher: string | undefined;
+    render(): string;
+}
+export {};

package/dist/flavors/asme/model.js

@@ -0,0 +1,123 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/asme: the single Standard class (the whole printed
+ * code as `number`), the renderer and the URN generator.
+ */
+class AsmeUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "asme"];
+        const specialType = this.specialType(id);
+        if (specialType !== undefined)
+            parts.push(specialType);
+        parts.push(id.publisher !== undefined ? id.publisher.toLowerCase() : "asme");
+        if (id.number !== undefined)
+            parts.push(id.number);
+        if (id.draft_year !== undefined)
+            parts.push(id.draft_year);
+        else if (id.year !== undefined)
+            parts.push(id.year);
+        if (specialType !== "ptc" && id.ptc_suffix !== undefined) {
+            parts.push(`ptc-suffix.${id.ptc_suffix}`);
+        }
+        if (specialType !== "csa" && id.csa_number !== undefined) {
+            parts.push(`csa.${id.csa_number}`);
+        }
+        if (id.first_publisher !== undefined) {
+            parts.push(`pub1.${id.first_publisher.toLowerCase()}`);
+        }
+        if (id.first_code !== undefined)
+            parts.push(`code1.${id.first_code}`);
+        if (id.second_publisher !== undefined) {
+            parts.push(`pub2.${id.second_publisher.toLowerCase()}`);
+        }
+        if (id.joint_publisher !== undefined) {
+            parts.push(`joint.${id.joint_publisher.toLowerCase()}`);
+        }
+        if (id.language !== undefined)
+            parts.push(id.language.toLowerCase());
+        if (id.reaffirmation !== undefined)
+            parts.push(`reaff.${id.reaffirmation}`);
+        if (id.revision_note !== undefined)
+            parts.push(`revnote.${id.revision_note}`);
+        if (id.parenthetical_revision !== undefined) {
+            parts.push(`prev.${id.parenthetical_revision}`);
+        }
+        return parts.join(":");
+    }
+    specialType(id) {
+        if (id.handbook === true)
+            return "handbook";
+        if (id.ptc_suffix !== undefined)
+            return "ptc";
+        if (id.csa_number !== undefined)
+            return "csa";
+        return undefined;
+    }
+}
+export class AsmeIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:asme:standard";
+    static urnGenerator = AsmeUrnGenerator;
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisher: { type: "string" },
+        number: { type: "string" },
+        year: { type: "string" },
+        reaffirmation: { type: "string" },
+        language: { type: "string" },
+        csa_number: { type: "string" },
+        draft_year: { type: "string" },
+        revision_note: { type: "string" },
+        parenthetical_revision: { type: "string" },
+        handbook: { type: "boolean", default: false },
+        ptc_suffix: { type: "string" },
+        joint_publisher: { type: "string" },
+        first_publisher: { type: "string" },
+        first_code: { type: "string" },
+        second_publisher: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "number", to: "number" }, { wire: "year", to: "year" }, { wire: "reaffirmation", to: "reaffirmation" }, { wire: "language", to: "language" }, { wire: "csa_number", to: "csa_number" }, { wire: "draft_year", to: "draft_year" }, { wire: "revision_note", to: "revision_note" }, { wire: "parenthetical_revision", to: "parenthetical_revision" }, { wire: "handbook", to: "handbook" }, { wire: "ptc_suffix", to: "ptc_suffix" }, { wire: "joint_publisher", to: "joint_publisher" }, { wire: "first_publisher", to: "first_publisher" }, { wire: "first_code", to: "first_code" }, { wire: "second_publisher", to: "second_publisher" });
+    render() {
+        const parts = [];
+        if (this.first_publisher !== undefined && this.first_code !== undefined) {
+            parts.push(this.first_publisher, this.first_code);
+            if (this.second_publisher !== undefined)
+                parts.push(`/${this.second_publisher}`);
+            if (this.number !== undefined && this.number !== "")
+                parts.push(this.number);
+        }
+        else if (this.joint_publisher !== undefined) {
+            parts.push(this.joint_publisher);
+            if (this.number !== undefined && this.number !== "")
+                parts.push(this.number);
+        }
+        else {
+            if (this.publisher !== undefined)
+                parts.push(this.publisher);
+            if (this.number !== undefined)
+                parts.push(this.number);
+        }
+        let result = parts.join(" ");
+        if (this.ptc_suffix !== undefined)
+            result += ` ${this.ptc_suffix}`;
+        if (this.csa_number !== undefined)
+            result += `/CSA ${this.csa_number}`;
+        if (this.handbook === true)
+            result += " Handbook";
+        if (this.draft_year !== undefined)
+            result += `-${this.draft_year}`;
+        else if (this.year !== undefined)
+            result += `-${this.year}`;
+        if (this.parenthetical_revision !== undefined)
+            result += ` ${this.parenthetical_revision}`;
+        if (this.language !== undefined)
+            result += ` (${this.language})`;
+        if (this.reaffirmation !== undefined)
+            result += ` (${this.reaffirmation})`;
+        if (this.revision_note !== undefined)
+            result += ` ${this.revision_note}`;
+        return result.replaceAll(/[–—]/g, "-");
+    }
+}
+registerType(AsmeIdentifier);

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

@@ -0,0 +1,2 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const astmGrammar: Grammar;

package/dist/flavors/astm/grammar.js

@@ -0,0 +1,110 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/astm/parser.rb — 1:1. The identifier alternation
+ * order is load-bearing (research_report first, standard last).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const dash = str("-");
+    const slash = str("/");
+    const colon = str(":");
+    const digit = match("[0-9]");
+    const digits = digit.repeat(1, Infinity);
+    const letter = match("[A-Z]");
+    const letters = letter.repeat(1, Infinity);
+    const publisher = () => str("ASTM").as("publisher").then(space.maybe());
+    rule("standard_letter", () => match("[A-G]").as("letter"));
+    rule("year_2digit", () => digit.repeat(2, 2).as("year"));
+    rule("reapproval", () => str("(").then(digit.repeat(4, 4).as("reapproval")).then(str(")")));
+    rule("comment", () => space.maybe().then(str("#")).then(match("[^#]").repeat(0, Infinity)));
+    rule("edition", () => str("e").then(digits.as("edition_number"))
+        .or(str("9TH")).or(str("8TH")).or(str("7TH")).or(str("6TH"))
+        .or(str("5TH")).or(str("4TH")).or(str("3RD")).or(str("2ND"))
+        .or(str("1ST"))
+        .as("edition"));
+    rule("sub_year", () => match("[a-c]").as("sub_year"));
+    rule("format_suffix", () => dash.then(str("EB").as("format_suffix")));
+    rule("format_suffix_no_dash", () => str("EB").as("format_suffix"));
+    rule("supplement", () => dash.then(str("SUP").as("supplement")).then(dash));
+    rule("research_report", () => publisher().maybe()
+        .then(str("RR").as("type"))
+        .then(colon)
+        .then(letter.then(digit.repeat(2, 2)).as("committee"))
+        .then(dash)
+        .then(digits.as("number")));
+    rule("manual", () => publisher().maybe()
+        .then(str("MNL").as("type"))
+        .then(str("TP").as("tp_designation").maybe())
+        .then(digits.as("number"))
+        .then(dash.then(ref(rules, "edition")).maybe())
+        .then(ref(rules, "supplement").then(ref(rules, "format_suffix_no_dash").maybe())
+        .or(ref(rules, "format_suffix").maybe())));
+    rule("monograph", () => publisher().maybe()
+        .then(str("MONO").as("type"))
+        .then(digits.as("number"))
+        .then(dash.then(ref(rules, "edition")).maybe())
+        .then(ref(rules, "format_suffix").maybe()));
+    rule("data_series_suffix", () => match("[A-Z]").as("suffix"));
+    rule("data_series_subseries_with_dash", () => dash.then(str("S")).then(digits.as("subseries")));
+    rule("data_series_subseries_no_dash", () => digits.as("subseries"));
+    rule("data_series_code", () => digits.as("number").then(str("HOL").as("hol_suffix")
+        .or(ref(rules, "data_series_suffix")
+        .then(
+    // A letter suffix may carry its subseries with the dash
+    // spelled out too ("DS55S-S1"), not only glued ("DS55S1").
+    ref(rules, "data_series_subseries_no_dash")
+        .or(ref(rules, "data_series_subseries_with_dash"))
+        .maybe()))
+        .or(ref(rules, "data_series_subseries_with_dash"))
+        .maybe()));
+    rule("data_series", () => publisher().maybe()
+        .then(str("DS").as("type"))
+        .then(ref(rules, "data_series_code"))
+        .then(ref(rules, "format_suffix").maybe()));
+    rule("work_in_progress", () => publisher().maybe()
+        .then(str("WK").as("type"))
+        .then(digits.as("number")));
+    rule("adjunct", () => publisher().maybe()
+        .then(str("ADJ").as("type"))
+        .then(letter.then(digits).or(letters).or(digits).as("designation"))
+        .then(dash.then(str("EA")).maybe().as("ea_suffix"))
+        .then(str("DVD").maybe().as("dvd_suffix")));
+    rule("technical_report_iso_astm", () => str("ISO/ASTMTR").as("type")
+        .then(digits.as("number"))
+        .then(ref(rules, "format_suffix").maybe())
+        .then(ref(rules, "comment").maybe()));
+    rule("technical_report_simple", () => publisher().maybe()
+        .then(str("TR").as("type"))
+        .then(digits.as("number"))
+        .then(ref(rules, "format_suffix").maybe())
+        .then(ref(rules, "comment").maybe()));
+    rule("technical_report", () => ref(rules, "technical_report_iso_astm").or(ref(rules, "technical_report_simple")));
+    rule("dual_unit", () => slash.then(ref(rules, "standard_letter")).then(digits).then(str("M").as("dual_m")));
+    rule("standard_code_with_letter", () => ref(rules, "standard_letter").then(digits.as("number")).then(ref(rules, "dual_unit").maybe()));
+    rule("standard_code_digit_only", () => digits.as("number"));
+    rule("standard", () => publisher().maybe()
+        .then(ref(rules, "standard_code_with_letter").or(ref(rules, "standard_code_digit_only")))
+        .then(dash.then(ref(rules, "year_2digit"))
+        .then(ref(rules, "sub_year").maybe())
+        .then(ref(rules, "reapproval").maybe())
+        .then(ref(rules, "edition").maybe())
+        .maybe())
+        .then(ref(rules, "comment").maybe()));
+    rule("identifier", () => ref(rules, "research_report")
+        .or(ref(rules, "technical_report"))
+        .or(ref(rules, "manual"))
+        .or(ref(rules, "monograph"))
+        .or(ref(rules, "data_series"))
+        .or(ref(rules, "work_in_progress"))
+        .or(ref(rules, "adjunct"))
+        .or(ref(rules, "standard")));
+    return rules;
+}
+export const astmGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

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

@@ -0,0 +1,2 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare function astmGrammarImplementation(): FlavorImplementation;

package/dist/flavors/astm/index.js

@@ -0,0 +1,127 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { astmGrammar } from "./grammar.js";
+import { AdjunctClass, DataSeriesClass, IsoDualPublishedClass, ManualClass, MonographClass, ResearchReportClass, StandardClass, TechnicalReportClass, WorkInProgressClass, } from "./model.js";
+/**
+ * Port of lib/pubid/astm/builder.rb — the parse-tree → identifier
+ * pipeline (class routing by type/number, code-column assembly,
+ * type-specific attributes, 2-digit year conversion).
+ */
+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;
+};
+function convertYear(yearStr) {
+    if (yearStr.length === 4)
+        return yearStr;
+    const yearInt = Number.parseInt(yearStr, 10);
+    return yearInt <= 24 ? `20${yearStr}` : `19${yearStr}`;
+}
+function determineClass(d) {
+    const type = str(d["type"]);
+    if ((type === undefined || type === "") && d["number"] !== undefined && d["letter"] === undefined) {
+        const numberStr = str(d["number"]) ?? "";
+        if (numberStr.startsWith("5"))
+            return IsoDualPublishedClass;
+        return StandardClass;
+    }
+    switch (type) {
+        case "RR": return ResearchReportClass;
+        case "MNL": return ManualClass;
+        case "MONO": return MonographClass;
+        case "DS": return DataSeriesClass;
+        case "WK": return WorkInProgressClass;
+        case "ADJ": return AdjunctClass;
+        case "TR":
+        case "ISO/ASTMTR":
+            return TechnicalReportClass;
+        default: return StandardClass;
+    }
+}
+class AstmBuilder {
+    build(tree) {
+        const d = Array.isArray(tree) ? Object.assign({}, ...tree) : tree;
+        const klass = determineClass(d);
+        const self = {};
+        if (d["letter"] !== undefined || d["number"] !== undefined) {
+            const letter = d["letter"] !== undefined &&
+                !(str(d["type"]) === "TR" && (str(d["publisher"]) ?? "").startsWith("ISO/ASTM"))
+                ? str(d["letter"])
+                : undefined;
+            self["letter"] = letter;
+            self["number"] = str(d["number"]);
+            self["suffix"] = str(d["suffix"]);
+            self["subseries"] = str(d["subseries"]);
+            self["dual_m"] = d["dual_m"] !== undefined;
+        }
+        if (str(d["type"]) === "ISO/ASTMTR") {
+            self["publisher"] = "ISO/ASTM";
+        }
+        else {
+            self["publisher"] = str(d["publisher"]) ?? "ASTM";
+        }
+        if (d["year"] !== undefined) {
+            self["year"] = convertYear(str(d["year"]) ?? "");
+        }
+        if (d["format_suffix"] !== undefined) {
+            self["format_suffix"] = `-${str(d["format_suffix"])}`;
+        }
+        this.buildTypeSpecific(self, klass, d);
+        return new klass(self);
+    }
+    buildTypeSpecific(self, klass, d) {
+        if (klass === ResearchReportClass && d["committee"] !== undefined) {
+            self["committee"] = str(d["committee"]);
+        }
+        if (klass === ManualClass) {
+            if (d["edition"] !== undefined)
+                self["edition"] = str(d["edition"]);
+            if (d["supplement"] !== undefined)
+                self["supplement"] = true;
+            if (d["tp_designation"] !== undefined)
+                self["tp_designation"] = str(d["tp_designation"]);
+        }
+        if (klass === MonographClass && d["edition"] !== undefined) {
+            self["edition"] = str(d["edition"]);
+        }
+        if (klass === DataSeriesClass && d["hol_suffix"] !== undefined) {
+            self["hol_suffix"] = true;
+        }
+        if (klass === AdjunctClass) {
+            if (d["designation"] !== undefined)
+                self["number"] = str(d["designation"]);
+            if (d["ea_suffix"] !== undefined && d["ea_suffix"] !== null)
+                self["ea_suffix"] = true;
+            if (d["dvd_suffix"] !== undefined && d["dvd_suffix"] !== null)
+                self["dvd_suffix"] = true;
+        }
+        if (klass === StandardClass || klass === IsoDualPublishedClass) {
+            if (d["sub_year"] !== undefined)
+                self["sub_year"] = str(d["sub_year"]);
+            if (d["reapproval"] !== undefined)
+                self["reapproval"] = str(d["reapproval"]);
+            const editionData = d["edition"];
+            if (editionData !== undefined) {
+                if (isObj(editionData)) {
+                    const editionNumber = str(editionData["edition_number"]);
+                    if (editionNumber !== undefined)
+                        self["edition"] = editionNumber;
+                }
+                else {
+                    self["edition"] = str(editionData);
+                }
+            }
+        }
+    }
+}
+export function astmGrammarImplementation() {
+    const builder = new AstmBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(astmGrammar, input);
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,42 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type AttributeTable, type FieldMapping } from "../../model/attribute.js";
+/**
+ * Port of lib/pubid/astm: the CodeNumber split columns (letter/number/
+ * suffix/subseries/dual_m) on every concrete class, the renderer family
+ * and the URN generator. Adjunct stores its designation directly in
+ * `number`.
+ */
+export declare class AstmCode {
+    readonly letter: string | undefined;
+    readonly number: string | undefined;
+    readonly suffix: string | undefined;
+    readonly subseries: string | undefined;
+    readonly dualM: boolean;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+}
+export declare abstract class AstmIdentifier extends BaseIdentifier {
+    static attributes: AttributeTable;
+    static mappings: FieldMapping[];
+    readonly number: string | undefined;
+    readonly letter: string | undefined;
+    readonly suffix: string | undefined;
+    readonly subseries: string | undefined;
+    readonly dual_m: boolean | undefined;
+    readonly publisher: string;
+    readonly year: string | undefined;
+    readonly format_suffix: string | undefined;
+    readonly type: string | undefined;
+    code(): AstmCode | undefined;
+    toUrn(): string;
+}
+export declare const StandardClass: IdentifierStatic;
+export declare const IsoDualPublishedClass: IdentifierStatic;
+export declare const ResearchReportClass: IdentifierStatic;
+export declare const DataSeriesClass: IdentifierStatic;
+export declare const TechnicalReportClass: IdentifierStatic;
+export declare const MonographClass: IdentifierStatic;
+export declare const AdjunctClass: IdentifierStatic;
+export declare const WorkInProgressClass: IdentifierStatic;
+export declare const ManualClass: IdentifierStatic;