@pubid/pubid 0.1.3 → 0.1.4

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

@@ -0,0 +1,159 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { PubidDate, Language, Iteration } from "../../model/component.js";
+import { Component } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { type IsoTypedStage } from "./stages.generated.js";
+/**
+ * Port of lib/pubid/iso/identifiers/* on the unified model. The typed
+ * stage is the single source of truth for stage and doctype; the wire
+ * hash carries only the non-published stage CODE under "stage"
+ * (identifier.rb's stage_to_kv). number/part/subpart are plain strings;
+ * date is flat year/month/day; publisher serializes only when it is
+ * not the class default.
+ */
+export declare function locateStage(abbr: string): IsoTypedStage | undefined;
+export declare function locateType(typeKey: string): IsoTypedStage[];
+export declare function locateStageByCode(code: string): IsoTypedStage | undefined;
+export declare function publishedStage(typeKey: string): IsoTypedStage | undefined;
+/** Tokens for the parser, longest first (array_to_str semantics). */
+export declare function stageTokens(typeKeys?: string[]): string[];
+/** TypedStage#abbreviation: long/short override, else abbr[0]; the
+ * parsed spelling (originalAbbr) decides long vs short via context. */
+export declare function stageAbbr(entry: IsoTypedStage, formatLong: boolean, originalAbbr?: string): string;
+/** The runtime typed-stage state: the registry entry + parsed spelling. */
+export interface TypedStageState {
+    entry: IsoTypedStage;
+    originalAbbr?: string | undefined;
+}
+export interface IsoLanguageState {
+    code: string;
+    originalCode: string;
+}
+/** The ISO Edition: number + original spelling ("Edition 13"). */
+export declare class IsoEdition extends Component {
+    readonly number: string | undefined;
+    readonly original_text: string | undefined;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+    toWire(): Record<string, unknown>;
+}
+export declare abstract class IsoIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    readonly subpart: string | undefined;
+    readonly stage_iteration: Iteration | undefined;
+    readonly date: PubidDate | undefined;
+    readonly edition: IsoEdition | undefined;
+    readonly languages: Language[] | undefined;
+    readonly all_parts: boolean | undefined;
+    readonly typedStageState: TypedStageState | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    /** The class's type key (drives URN type component + class identity). */
+    typeKey(): string;
+    root(): IsoIdentifier;
+    /** detect_stage_format_long: the parsed spelling picks long form. */
+    protected stageFormatLong(): boolean;
+    /** detect_language_code_format: single (E) vs iso (en). */
+    protected languageSingle(): boolean;
+    protected stageString(): string;
+    /** Render with an EXPLICIT long-format flag (the supplement
+     * renderer propagates its own context to the base). */
+    renderWithFormat(formatLong: boolean): string;
+    /** Ruby SupplementRenderer renders the base with the wrapper's
+     * detected context (stage_format_long propagates down the chain;
+     * with_date being non-nil pins it against re-detection — a nested
+     * amendment renders "AMD" under a "CD Cor" top but "Amd" under a
+     * "Cor." top). */
+    renderAsSupplementBase(long: boolean): string;
+    private stageStringFor;
+    protected numberPortion(withDate: boolean): string;
+    protected languagePortion(single: boolean): string;
+}
+/** identifier.rb's base key_value block (the single-document whitelist). */
+export declare const ISO_MAPPINGS: FieldMapping[];
+/** The ISO Publisher component: "ISO/IEC/IEEE". */
+export declare class IsoPublisher {
+    readonly publisher: string;
+    readonly copublisher: string[] | undefined;
+    constructor(attrs: {
+        publisher?: unknown;
+        copublisher?: unknown;
+    });
+    render(): string;
+}
+/** Single documents (everything except supplements, TcDocument, Bundled). */
+export declare abstract class IsoSingleIdentifier extends IsoIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly publisher: IsoPublisher | undefined;
+    readonly copublishers: IsoPublisher[] | undefined;
+    readonly typedStageState: TypedStageState | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    render(): string;
+}
+declare class IsoUrnGenerator extends BaseUrnGenerator<IsoIdentifier> {
+    generate(): string;
+    private originator;
+    private typeComponent;
+    private stageComponent;
+    private generateBaseUrn;
+    private generateSupplementUrn;
+}
+export declare abstract class IsoSupplementIdentifier extends IsoSingleIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly base: IsoIdentifier | undefined;
+    render(): string;
+    renderAsSupplementBase(long: boolean): string;
+    private renderSupplement;
+}
+export declare abstract class IsoBundledBase extends IsoSingleIdentifier {
+}
+export declare function isoClassForType(typeKey: string): IdentifierStatic | undefined;
+export declare class IsoDirectives extends IsoSingleIdentifier {
+    static polymorphicName: string;
+    static typeKey: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static urnGenerator: typeof IsoUrnGenerator;
+    readonly subgroup: string | undefined;
+    render(): string;
+}
+export declare class IsoDirectivesSupplement extends IsoSupplementIdentifier {
+    static polymorphicName: string;
+    static typeKey: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static urnGenerator: typeof IsoUrnGenerator;
+    readonly supplement_publisher: string | undefined;
+    readonly base: IsoIdentifier | undefined;
+    render(): string;
+}
+export declare class IsoTcDocument extends IsoIdentifier {
+    static polymorphicName: string;
+    static typeKey: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static urnGenerator: typeof IsoUrnGenerator;
+    readonly publisher: IsoPublisher | undefined;
+    readonly tc_type: string | undefined;
+    readonly tc_number: string | undefined;
+    readonly sc_type: string | undefined;
+    readonly sc_number: string | undefined;
+    readonly wg_type: string | undefined;
+    readonly wg_number: string | undefined;
+    render(): string;
+}
+export declare class IsoBundledIdentifier extends IsoIdentifier {
+    static polymorphicName: string;
+    static typeKey: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static urnGenerator: typeof IsoUrnGenerator;
+    readonly base_document: IsoIdentifier | undefined;
+    readonly supplements: IsoIdentifier[];
+    render(): string;
+}
+export {};