@northguild/gmt 1.18.0 → 1.19.0

package/dist/internal/ediDateTimeFields.d.ts

@@ -0,0 +1,97 @@
+import { type EdiKind, type EdiStandard } from "./ediGrammar.js";
+/**
+ * Read a single EDI date/time value against a format code of one kind, as one ISO 8601 string:
+ * the reader behind every public parser of a date, a time, a local date-time and a date-time
+ * with an offset.
+ *
+ * - The code must be one of `kind` in its standard's table (`ediGrammar.ts`); a code of another
+ *   kind, a period or range code and a code that is not read return `""`.
+ * - The value is tested against the code's grammar, its digits are read into a field bag, and
+ *   the bag goes through `Temporal.PlainDate.from` / `PlainTime.from` / `PlainDateTime.from` with
+ *   `overflow: "reject"`: the grammar proves shape, Temporal proves the date is real.
+ * - A date is `YYYY-MM-DD`, a time `HH:MM:SS` and a local date-time `YYYY-MM-DDTHH:MM:SS`.
+ *   Seconds are always written, `00` for a mask without them.
+ * - A date-time with an offset (`205`, `208`; `303` and `304`, whose `ZZZ` is `[+-]HH`, `UTC` or
+ *   `GMT`) is the wall clock as written with its offset, `YYYY-MM-DDTHH:MM:SS±HH:MM`. The wall
+ *   clock and the offset are joined as an extended ISO string, read by `toOffsetInstant` and
+ *   written by `fromOffsetInstant`; no offset digit is moved by hand.
+ * - Never throws: any failure is `""`.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of value the calling function reads
+ * @param code the 2379 or 1250 format code
+ * @param value the element value, after the interchange has been unescaped
+ * @returns the value as one ISO 8601 string, or `""`
+ *
+ * @example readEdiValue("edifact", "date", "102", "20240615") // "2024-06-15"
+ * @example readEdiValue("edifact", "dateTime", "203", "202406151430") // "2024-06-15T14:30:00"
+ * @example readEdiValue("edifact", "offsetDateTime", "303", "202406151430+02") // "2024-06-15T14:30:00+02:00"
+ * @example readEdiValue("x12", "date", "DB", "06152024") // "2024-06-15"
+ * @example readEdiValue("edifact", "date", "203", "202406151430") // "" (a date-time code)
+ * @example readEdiValue("edifact", "date", "102", "20230229") // "" (2023 has no 29 February)
+ */
+export declare function readEdiValue(standard: EdiStandard, kind: EdiKind, code: string, value: string): string;
+/**
+ * Read an EDI period or range against a format code of one kind, as its two ends: the reader
+ * behind every public parser of a period (UNTDID 2379) and a range (X12 1250).
+ *
+ * - The code must be one of `kind`; a single-value code and a code of another kind return null.
+ * - Each half is read as `readEdiValue` reads a date or a local date-time. A 2379 period is run
+ *   together and a 1250 range has exactly one hyphen: the grammar holds that.
+ * - An end that precedes its start returns null (**GMT rule**: a reversed period names no span
+ *   of time). An end equal to its start is a valid period.
+ * - Never throws: any failure is null.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of period or range the calling function reads
+ * @param code the 2379 or 1250 format code
+ * @param value the element value
+ * @returns the two ends as ISO 8601 strings, or null
+ *
+ * @example readEdiRange("edifact", "datePeriod", "718", "2024061520240620") // { start: "2024-06-15", end: "2024-06-20" }
+ * @example readEdiRange("x12", "dateTimeRange", "RDT", "202406151430-202406201600") // { start: "2024-06-15T14:30:00", end: "2024-06-20T16:00:00" }
+ * @example readEdiRange("x12", "dateRange", "RD8", "20240620-20240615") // null (the end precedes the start)
+ * @example readEdiRange("edifact", "datePeriod", "102", "20240615") // null (a single date code)
+ */
+export declare function readEdiRange(standard: EdiStandard, kind: EdiKind, code: string, value: string): {
+    start: string;
+    end: string;
+} | null;
+/**
+ * Read an X12 data element 337 (Time) value as an ISO 8601 time, `HH:MM:SS[.f[f]]`.
+ *
+ * - The value is tested against the grammar of each form in the element's layout table
+ *   (`HHMM`, `HHMMSS`, `HHMMSSD`, `HHMMSSDD`; `ediGrammar.ts`). The four masks have four lengths,
+ *   so at most one matches. Its digits are read by part name, and the fields go through
+ *   `Temporal.PlainTime.from` with `overflow: "reject"`.
+ * - Decimal seconds become the fraction of the second exactly: one digit is tenths, two are
+ *   hundredths. Temporal writes no trailing zero, so `14304550` is `14:30:45.5`.
+ * - `""` for a non-string, a value of any other length or shape, hour 24, and minute or second
+ *   60. Never throws.
+ *
+ * @param value the element 337 value as transmitted
+ * @returns the time, or `""`
+ *
+ * @example readX12Time("1430") // "14:30:00"
+ * @example readX12Time("143045") // "14:30:45"
+ * @example readX12Time("14300012") // "14:30:00.12"
+ * @example readX12Time("2430") // ""
+ */
+export declare function readX12Time(value: string): string;
+/**
+ * Read the date (element 373, `CCYYMMDD`) and the time (element 337) of an X12 segment as one
+ * local date-time, `YYYY-MM-DDTHH:MM:SS[.f[f]]`.
+ *
+ * - The date is read by the `CCYYMMDD` mask of the 1250 code `D8` (one grammar, one reader) and
+ *   the time by `readX12Time`; Temporal joins the two.
+ * - `""` when either is missing, is not a string or is not a real date or time. Never throws.
+ *
+ * @param date the element 373 value as transmitted
+ * @param time the element 337 value as transmitted
+ * @returns the local date-time, or `""`
+ *
+ * @example readX12DateAndTime("20240615", "1430") // "2024-06-15T14:30:00"
+ * @example readX12DateAndTime("20240615", "14300012") // "2024-06-15T14:30:00.12"
+ * @example readX12DateAndTime("20240615", "") // ""
+ */
+export declare function readX12DateAndTime(date: string, time: string): string;

package/dist/internal/ediDateTimeFields.js

@@ -0,0 +1,288 @@
+// Not re-exported from `internal/index.ts`: `toOffsetInstant` reads that barrel at module top
+// level (`TIME_ZONE_ANNOTATION`), so a barrel entry for this module would close a cycle and leave
+// the constant undefined when `toOffsetInstant` evaluates. Import this file directly.
+import { Temporal } from "@js-temporal/polyfill";
+import { fromOffsetInstant } from "../instant/convert/fromOffsetInstant.js";
+import { toOffsetInstant } from "../instant/convert/toOffsetInstant.js";
+import { MILLISECONDS_PER_DECIMAL_SECOND, X12_TIME_ELEMENT_FORMS, X12_TIME_ELEMENT_GRAMMAR, X12_TIME_ELEMENT_LAYOUT, ediCodeOfKind, } from "./ediGrammar.js";
+/**
+ * The bag member each digit part of a mask fills. The offset parts (`ZS`, `ZH`, `ZM`) and `ZZZ`
+ * are text, not numbers, and are read apart.
+ */
+const NUMBER_FIELD_OF_PART = {
+    CCYY: "year",
+    MM: "month",
+    DD: "day",
+    HH: "hour",
+    MI: "minute",
+    SS: "second",
+    SD: "tenths",
+    SDD: "hundredths",
+};
+/**
+ * The two `ZZZ` literals that are +00:00. `UTC` is what the SMDG IFTSAI 2.0 and BAPLIE 3.1.1
+ * guides write in a `303` value. `GMT` is the same scale by UN/ECE Recommendation 7 ¶12:
+ * "Co-ordinated Universal Time (formerly known as Greenwich Mean Time)".
+ */
+const UTC_LITERALS = ["UTC", "GMT"];
+/**
+ * Read a single EDI date/time value against a format code of one kind, as one ISO 8601 string:
+ * the reader behind every public parser of a date, a time, a local date-time and a date-time
+ * with an offset.
+ *
+ * - The code must be one of `kind` in its standard's table (`ediGrammar.ts`); a code of another
+ *   kind, a period or range code and a code that is not read return `""`.
+ * - The value is tested against the code's grammar, its digits are read into a field bag, and
+ *   the bag goes through `Temporal.PlainDate.from` / `PlainTime.from` / `PlainDateTime.from` with
+ *   `overflow: "reject"`: the grammar proves shape, Temporal proves the date is real.
+ * - A date is `YYYY-MM-DD`, a time `HH:MM:SS` and a local date-time `YYYY-MM-DDTHH:MM:SS`.
+ *   Seconds are always written, `00` for a mask without them.
+ * - A date-time with an offset (`205`, `208`; `303` and `304`, whose `ZZZ` is `[+-]HH`, `UTC` or
+ *   `GMT`) is the wall clock as written with its offset, `YYYY-MM-DDTHH:MM:SS±HH:MM`. The wall
+ *   clock and the offset are joined as an extended ISO string, read by `toOffsetInstant` and
+ *   written by `fromOffsetInstant`; no offset digit is moved by hand.
+ * - Never throws: any failure is `""`.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of value the calling function reads
+ * @param code the 2379 or 1250 format code
+ * @param value the element value, after the interchange has been unescaped
+ * @returns the value as one ISO 8601 string, or `""`
+ *
+ * @example readEdiValue("edifact", "date", "102", "20240615") // "2024-06-15"
+ * @example readEdiValue("edifact", "dateTime", "203", "202406151430") // "2024-06-15T14:30:00"
+ * @example readEdiValue("edifact", "offsetDateTime", "303", "202406151430+02") // "2024-06-15T14:30:00+02:00"
+ * @example readEdiValue("x12", "date", "DB", "06152024") // "2024-06-15"
+ * @example readEdiValue("edifact", "date", "203", "202406151430") // "" (a date-time code)
+ * @example readEdiValue("edifact", "date", "102", "20230229") // "" (2023 has no 29 February)
+ */
+export function readEdiValue(standard, kind, code, value) {
+    try {
+        const halves = readHalves(ediCodeOfKind(standard, kind, code), value);
+        return halves === null || halves.length !== 1 ? "" : halves[0];
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Read an EDI period or range against a format code of one kind, as its two ends: the reader
+ * behind every public parser of a period (UNTDID 2379) and a range (X12 1250).
+ *
+ * - The code must be one of `kind`; a single-value code and a code of another kind return null.
+ * - Each half is read as `readEdiValue` reads a date or a local date-time. A 2379 period is run
+ *   together and a 1250 range has exactly one hyphen: the grammar holds that.
+ * - An end that precedes its start returns null (**GMT rule**: a reversed period names no span
+ *   of time). An end equal to its start is a valid period.
+ * - Never throws: any failure is null.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of period or range the calling function reads
+ * @param code the 2379 or 1250 format code
+ * @param value the element value
+ * @returns the two ends as ISO 8601 strings, or null
+ *
+ * @example readEdiRange("edifact", "datePeriod", "718", "2024061520240620") // { start: "2024-06-15", end: "2024-06-20" }
+ * @example readEdiRange("x12", "dateTimeRange", "RDT", "202406151430-202406201600") // { start: "2024-06-15T14:30:00", end: "2024-06-20T16:00:00" }
+ * @example readEdiRange("x12", "dateRange", "RD8", "20240620-20240615") // null (the end precedes the start)
+ * @example readEdiRange("edifact", "datePeriod", "102", "20240615") // null (a single date code)
+ */
+export function readEdiRange(standard, kind, code, value) {
+    try {
+        const entry = ediCodeOfKind(standard, kind, code);
+        const halves = readHalves(entry, value);
+        if (entry === null || halves === null || halves.length !== 2) {
+            return null;
+        }
+        const [start, end] = halves;
+        return endPrecedesStart(entry.valueKind, start, end)
+            ? null
+            : { start, end };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read an X12 data element 337 (Time) value as an ISO 8601 time, `HH:MM:SS[.f[f]]`.
+ *
+ * - The value is tested against the grammar of each form in the element's layout table
+ *   (`HHMM`, `HHMMSS`, `HHMMSSD`, `HHMMSSDD`; `ediGrammar.ts`). The four masks have four lengths,
+ *   so at most one matches. Its digits are read by part name, and the fields go through
+ *   `Temporal.PlainTime.from` with `overflow: "reject"`.
+ * - Decimal seconds become the fraction of the second exactly: one digit is tenths, two are
+ *   hundredths. Temporal writes no trailing zero, so `14304550` is `14:30:45.5`.
+ * - `""` for a non-string, a value of any other length or shape, hour 24, and minute or second
+ *   60. Never throws.
+ *
+ * @param value the element 337 value as transmitted
+ * @returns the time, or `""`
+ *
+ * @example readX12Time("1430") // "14:30:00"
+ * @example readX12Time("143045") // "14:30:45"
+ * @example readX12Time("14300012") // "14:30:00.12"
+ * @example readX12Time("2430") // ""
+ */
+export function readX12Time(value) {
+    try {
+        if (typeof value !== "string") {
+            return "";
+        }
+        for (const form of X12_TIME_ELEMENT_FORMS) {
+            const match = X12_TIME_ELEMENT_GRAMMAR[form].exec(value);
+            if (match !== null) {
+                return timeOf(readBag(X12_TIME_ELEMENT_LAYOUT[form].start, match.slice(1)));
+            }
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Read the date (element 373, `CCYYMMDD`) and the time (element 337) of an X12 segment as one
+ * local date-time, `YYYY-MM-DDTHH:MM:SS[.f[f]]`.
+ *
+ * - The date is read by the `CCYYMMDD` mask of the 1250 code `D8` (one grammar, one reader) and
+ *   the time by `readX12Time`; Temporal joins the two.
+ * - `""` when either is missing, is not a string or is not a real date or time. Never throws.
+ *
+ * @param date the element 373 value as transmitted
+ * @param time the element 337 value as transmitted
+ * @returns the local date-time, or `""`
+ *
+ * @example readX12DateAndTime("20240615", "1430") // "2024-06-15T14:30:00"
+ * @example readX12DateAndTime("20240615", "14300012") // "2024-06-15T14:30:00.12"
+ * @example readX12DateAndTime("20240615", "") // ""
+ */
+export function readX12DateAndTime(date, time) {
+    try {
+        const dateOnly = readEdiValue("x12", "date", "D8", date);
+        const timeOnly = readX12Time(time);
+        if (dateOnly === "" || timeOnly === "") {
+            return "";
+        }
+        return Temporal.PlainDate.from(dateOnly)
+            .toPlainDateTime(Temporal.PlainTime.from(timeOnly))
+            .toString();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The value as one ISO 8601 string per half: one for a single value, two for a period or range.
+ * Null when there is no code, the value is not a string, it does not match the code's grammar,
+ * or a half states an offset no instant can be read at. Temporal throws for a date or time that
+ * is not real.
+ */
+function readHalves(entry, value) {
+    if (entry === null || typeof value !== "string") {
+        return null;
+    }
+    const match = entry.grammar.exec(value);
+    if (match === null) {
+        return null;
+    }
+    const captures = match.slice(1);
+    const { start, end } = entry.layout;
+    const bags = end === undefined
+        ? [readBag(start, captures)]
+        : [
+            readBag(start, captures.slice(0, start.length)),
+            readBag(end, captures.slice(start.length)),
+        ];
+    const halves = [];
+    for (const bag of bags) {
+        const half = HALF_READERS[entry.valueKind](bag);
+        if (half === null) {
+            return null;
+        }
+        halves.push(half);
+    }
+    return halves;
+}
+/** The captured digits of one half, read by part name into a field bag. */
+function readBag(parts, captures) {
+    const bag = {};
+    const text = {};
+    parts.forEach((part, index) => {
+        const raw = captures[index] ?? "";
+        const field = NUMBER_FIELD_OF_PART[part];
+        if (field === undefined) {
+            text[part] = raw;
+        }
+        else {
+            bag[field] = Number(raw);
+        }
+    });
+    const offset = offsetOf(text);
+    return offset === null ? bag : { ...bag, offset };
+}
+/**
+ * The `±HH:MM` a half states: `ZS`, `ZH` and `ZM` joined, or the three `ZZZ` characters read as
+ * a signed hour (UN/ECE Rec 7 ¶12, hours only) or as `UTC` or `GMT` (+00:00). The grammar
+ * admits nothing else in `ZZZ`. Null for a half with no offset.
+ */
+function offsetOf(text) {
+    if (text.ZS !== undefined) {
+        return `${text.ZS}${text.ZH}:${text.ZM}`;
+    }
+    if (text.ZZZ === undefined) {
+        return null;
+    }
+    return UTC_LITERALS.includes(text.ZZZ) ? "+00:00" : `${text.ZZZ}:00`;
+}
+/**
+ * The time of day of a half that has no date, built by Temporal from its fields. The decimal
+ * seconds of X12 data element 337 are counted in milliseconds: "1" is one tenth (100 ms) and
+ * "12" is twelve hundredths (120 ms). A mask without them, which is every 2379 and 1250 mask,
+ * gives 0.
+ */
+function timeOf(bag) {
+    return Temporal.PlainTime.from({
+        hour: bag.hour,
+        minute: bag.minute,
+        second: bag.second ?? 0,
+        millisecond: (bag.tenths ?? 0) * MILLISECONDS_PER_DECIMAL_SECOND.SD +
+            (bag.hundredths ?? 0) * MILLISECONDS_PER_DECIMAL_SECOND.SDD,
+    }, { overflow: "reject" }).toString();
+}
+/** The wall clock of a half that has a date and a time, built by Temporal from its fields. */
+function localDateTime(bag) {
+    return Temporal.PlainDateTime.from({
+        year: bag.year,
+        month: bag.month,
+        day: bag.day,
+        hour: bag.hour,
+        minute: bag.minute,
+        second: bag.second ?? 0,
+    }, { overflow: "reject" }).toString();
+}
+/**
+ * Each kind's reader: one half's fields as the ISO 8601 string of that kind. Temporal throws for
+ * a date or time that is not real; null is for an offset no instant can be read at.
+ */
+const HALF_READERS = {
+    date: (bag) => Temporal.PlainDate.from({ year: bag.year, month: bag.month, day: bag.day }, { overflow: "reject" }).toString(),
+    time: timeOf,
+    dateTime: localDateTime,
+    // The wall clock and its offset, read by `toOffsetInstant` and written back by
+    // `fromOffsetInstant`: the pair's own string, so `-00:00` is `+00:00` and the result reads
+    // back through the instant functions.
+    offsetDateTime: (bag) => {
+        const pair = toOffsetInstant(`${localDateTime(bag)}${bag.offset ?? ""}`);
+        const written = pair === null ? "" : fromOffsetInstant(pair);
+        return written === "" ? null : written;
+    },
+};
+/**
+ * GMT rule: a reversed period names no span of time. Two dates compare by calendar date and two
+ * local date-times to the second.
+ */
+function endPrecedesStart(valueKind, start, end) {
+    return valueKind === "date"
+        ? Temporal.PlainDate.compare(end, start) < 0
+        : Temporal.PlainDateTime.compare(end, start) < 0;
+}

package/dist/internal/ediDateTimeWriter.d.ts

@@ -0,0 +1,92 @@
+import { type EdiKind, type EdiStandard } from "./ediGrammar.js";
+/**
+ * Write one ISO 8601 value as a single EDI date/time value in a format code of one kind: the
+ * inverse of `readEdiValue`, driven by the same layout tables (`ediGrammar.ts`), so what one
+ * writes the other reads back.
+ *
+ * - The code must be one of `kind`; a code of another kind, a period or range code and a code
+ *   that is not written return `""`.
+ * - The kind fixes the ISO 8601 string `value` must be, as the house plain functions fix theirs:
+ *   a date is what `isValidDate` accepts, a time what `isValidTime` accepts, a local date-time
+ *   what `isValidDateTime` accepts, and a date-time with an offset what `toOffsetInstant` reads
+ *   (an offset, `Z`, or a bracketed zone that agrees). Temporal then reads the fields; no digit
+ *   of the input is sliced.
+ * - Precision is cut to the mask and never refused: a fraction of a second is dropped under
+ *   every 2379 and 1250 mask (none has decimal seconds) and the seconds under a mask with no
+ *   `SS`. The cut is a truncation, never a rounding, so a written value never names a later
+ *   minute or second than its input.
+ * - A value with an offset is written on its own wall clock, never the UTC clock. `ZHHMM` holds
+ *   whole minutes and `ZZZ` whole hours, always written as the signed hour of UN/ECE
+ *   Recommendation 7 ¶12 (`+02`), never `UTC` or `GMT`. An offset the field cannot hold returns
+ *   `""`: rounding it would name another instant.
+ * - A year outside 0000–9999 returns `""`: `CCYY` is four digits and no sign.
+ * - Never throws: any failure is `""`.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of value the calling function writes
+ * @param code the 2379 or 1250 format code
+ * @param value one ISO 8601 string of that kind
+ * @returns the element value, or `""`
+ *
+ * @example writeEdiValue("edifact", "dateTime", "203", "2024-06-15T14:30:45") // "202406151430"
+ * @example writeEdiValue("edifact", "offsetDateTime", "303", "2024-06-15T14:30:00+02:00") // "202406151430+02"
+ * @example writeEdiValue("x12", "date", "DB", "2024-06-15") // "06152024"
+ * @example writeEdiValue("edifact", "offsetDateTime", "303", "2024-06-15T14:30:00+05:30") // "" (ZZZ holds whole hours)
+ * @example writeEdiValue("edifact", "date", "102", "2024-06-15T14:30:00") // "" (a date-time is not a date)
+ */
+export declare function writeEdiValue(standard: EdiStandard, kind: EdiKind, code: string, value: string): string;
+/**
+ * Write two ISO 8601 values as an EDI period or range in a format code of one kind: the inverse
+ * of `readEdiRange`.
+ *
+ * - The code must be one of `kind`; a single-value code and a code of another kind return `""`.
+ * - Each end is read and written as `writeEdiValue` reads and writes a date or a local
+ *   date-time. The halves are joined by what the standard transmits: nothing for UNTDID 2379,
+ *   one hyphen for X12 1250.
+ * - An end that precedes its start returns `""` (**GMT rule**: a reversed period names no span
+ *   of time). The ends are compared as given, before either is cut to the mask, so an end 35
+ *   seconds before its start is reversed under a minute mask too. An end equal to its start is
+ *   written.
+ * - Never throws: any failure is `""`.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of period or range the calling function writes
+ * @param code the 2379 or 1250 format code
+ * @param start the first end, one ISO 8601 string of the kind's half
+ * @param end the second end, of the same kind
+ * @returns the element value, or `""`
+ *
+ * @example writeEdiRange("edifact", "datePeriod", "718", "2024-06-15", "2024-06-20") // "2024061520240620"
+ * @example writeEdiRange("x12", "dateRange", "RD8", "2024-06-15", "2024-06-20") // "20240615-20240620"
+ * @example writeEdiRange("x12", "dateRange", "RD8", "2024-06-20", "2024-06-15") // "" (the end precedes the start)
+ */
+export declare function writeEdiRange(standard: EdiStandard, kind: EdiKind, code: string, start: string, end: string): string;
+/**
+ * Write one ISO 8601 time as an X12 data element 337 (Time) value in one of the element's four
+ * forms: the inverse of `readX12Time`, driven by the same layout table (`ediGrammar.ts`), so
+ * what one writes the other reads back.
+ *
+ * - The form is the element's own mask (`HHMM`, `HHMMSS`, `HHMMSSD`, `HHMMSSDD`), looked up
+ *   exactly and by own key. A data element 1250 code (`TM`, `TS`) and any other string return
+ *   `""`.
+ * - `value` is a time, as `isValidTime` accepts it; Temporal then reads the fields. No digit of
+ *   the input is sliced.
+ * - The form alone fixes the digits written. It is never read off the value, so the width of the
+ *   field does not depend on the data: a time with no fraction is `14300000` under `HHMMSSDD`.
+ * - Precision is cut to the mask and never refused: `D` is the whole tenths of the second and
+ *   `DD` its whole hundredths. The cut is a truncation, never a rounding, so a written value
+ *   never names a later second than its input.
+ * - Never throws: any failure is `""`.
+ *
+ * @param form the element's mask
+ * @param value one ISO 8601 time
+ * @returns the element value, or `""`
+ *
+ * @example writeX12TimeElement("HHMMSSDD", "14:30:00.12") // "14300012"
+ * @example writeX12TimeElement("HHMMSSD", "14:30:00.12") // "1430001" (cut, not rounded)
+ * @example writeX12TimeElement("HHMMSSDD", "14:30") // "14300000"
+ * @example writeX12TimeElement("HHMM", "14:30:45.999") // "1430"
+ * @example writeX12TimeElement("TS", "14:30:45") // "" (a 1250 code, not a mask)
+ * @example writeX12TimeElement("HHMM", "2024-06-15T14:30:00") // "" (a date-time is not a time)
+ */
+export declare function writeX12TimeElement(form: string, value: string): string;