@northguild/gmt 1.17.0 → 1.19.0

package/dist/intermodal/validate/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./isValidEdifactDate.js";
+export * from "./isValidEdifactDatePeriod.js";
+export * from "./isValidEdifactDateTime.js";
+export * from "./isValidEdifactDateTimePeriod.js";
+export * from "./isValidEdifactDtmFormat.js";
+export * from "./isValidEdifactOffsetDateTime.js";
+export * from "./isValidEdifactTime.js";
+export * from "./isValidEpcisEvent.js";
+export * from "./isValidEpcisEventTime.js";
+export * from "./isValidEpcisTimeZoneOffset.js";
+export * from "./isValidX12Date.js";
+export * from "./isValidX12DateAndTime.js";
+export * from "./isValidX12DateRange.js";
+export * from "./isValidX12DateTime.js";
+export * from "./isValidX12DateTimePeriodFormat.js";
+export * from "./isValidX12DateTimeRange.js";
+export * from "./isValidX12Time.js";
+export * from "./isValidX12TimeCode.js";

package/dist/intermodal/validate/index.js

@@ -0,0 +1,18 @@
+export * from "./isValidEdifactDate.js";
+export * from "./isValidEdifactDatePeriod.js";
+export * from "./isValidEdifactDateTime.js";
+export * from "./isValidEdifactDateTimePeriod.js";
+export * from "./isValidEdifactDtmFormat.js";
+export * from "./isValidEdifactOffsetDateTime.js";
+export * from "./isValidEdifactTime.js";
+export * from "./isValidEpcisEvent.js";
+export * from "./isValidEpcisEventTime.js";
+export * from "./isValidEpcisTimeZoneOffset.js";
+export * from "./isValidX12Date.js";
+export * from "./isValidX12DateAndTime.js";
+export * from "./isValidX12DateRange.js";
+export * from "./isValidX12DateTime.js";
+export * from "./isValidX12DateTimePeriodFormat.js";
+export * from "./isValidX12DateTimeRange.js";
+export * from "./isValidX12Time.js";
+export * from "./isValidX12TimeCode.js";

package/dist/intermodal/validate/isValidEdifactDate.d.ts

@@ -0,0 +1,26 @@
+import type { EdifactDateFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * calendar date in a date format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `102` | `CCYYMMDD` | "Calendar date: C = Century ; Y = Year ; M = Month ; D = Day." |
+ *
+ * - True exactly when `parseEdifactDate` returns a date for the same arguments: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - Checks the calendar as well as the shape: 31 June and 29 February 2023 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "20240615")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDate("20240615", "102") // true
+ * @example isValidEdifactDate("20230229", "102") // false (2023 has no 29 February)
+ * @example isValidEdifactDate("240615", "102") // false (a two-digit year is not read)
+ * @example isValidEdifactDate("202406151430", "203") // false (a date-time code)
+ */
+export declare function isValidEdifactDate(value: string, format: EdifactDateFormat): boolean;

package/dist/intermodal/validate/isValidEdifactDate.js

@@ -0,0 +1,28 @@
+import { parseEdifactDate } from "../parse/parseEdifactDate.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * calendar date in a date format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `102` | `CCYYMMDD` | "Calendar date: C = Century ; Y = Year ; M = Month ; D = Day." |
+ *
+ * - True exactly when `parseEdifactDate` returns a date for the same arguments: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - Checks the calendar as well as the shape: 31 June and 29 February 2023 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "20240615")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDate("20240615", "102") // true
+ * @example isValidEdifactDate("20230229", "102") // false (2023 has no 29 February)
+ * @example isValidEdifactDate("240615", "102") // false (a two-digit year is not read)
+ * @example isValidEdifactDate("202406151430", "203") // false (a date-time code)
+ */
+export function isValidEdifactDate(value, format) {
+    return parseEdifactDate(value, format) !== "";
+}

package/dist/intermodal/validate/isValidEdifactDatePeriod.d.ts

@@ -0,0 +1,28 @@
+import type { EdifactDatePeriodFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a period
+ * between two real calendar dates, in a date period format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `718` | `CCYYMMDD-CCYYMMDD` | "A period of time specified by giving the start date followed by the end date (both including century). Data is to be transmitted as consecutive characters without hyphen." |
+ *
+ * - True exactly when `parseEdifactDatePeriod` returns a period for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A period is valid in its wire form only, with no hyphen: `"20240615-20240620"` is false.
+ * - A period whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: 29 February 2023 in either date is false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "2024061520240620")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDatePeriod("2024061520240620", "718") // true
+ * @example isValidEdifactDatePeriod("20240615-20240620", "718") // false (a period is transmitted without a hyphen)
+ * @example isValidEdifactDatePeriod("2024062020240615", "718") // false (the end precedes the start)
+ * @example isValidEdifactDatePeriod("20240615", "718") // false (one date)
+ */
+export declare function isValidEdifactDatePeriod(value: string, format: EdifactDatePeriodFormat): boolean;

package/dist/intermodal/validate/isValidEdifactDatePeriod.js

@@ -0,0 +1,30 @@
+import { parseEdifactDatePeriod } from "../parse/parseEdifactDatePeriod.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a period
+ * between two real calendar dates, in a date period format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `718` | `CCYYMMDD-CCYYMMDD` | "A period of time specified by giving the start date followed by the end date (both including century). Data is to be transmitted as consecutive characters without hyphen." |
+ *
+ * - True exactly when `parseEdifactDatePeriod` returns a period for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A period is valid in its wire form only, with no hyphen: `"20240615-20240620"` is false.
+ * - A period whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: 29 February 2023 in either date is false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "2024061520240620")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDatePeriod("2024061520240620", "718") // true
+ * @example isValidEdifactDatePeriod("20240615-20240620", "718") // false (a period is transmitted without a hyphen)
+ * @example isValidEdifactDatePeriod("2024062020240615", "718") // false (the end precedes the start)
+ * @example isValidEdifactDatePeriod("20240615", "718") // false (one date)
+ */
+export function isValidEdifactDatePeriod(value, format) {
+    return parseEdifactDatePeriod(value, format) !== null;
+}

package/dist/intermodal/validate/isValidEdifactDateTime.d.ts

@@ -0,0 +1,30 @@
+import type { EdifactDateTimeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * date and time in a format code with no offset (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `203` | `CCYYMMDDHHMM` | "Calendar date including time with minutes" |
+ * | `204` | `CCYYMMDDHHMMSS` | "Calendar date including time with seconds" |
+ *
+ * - True exactly when `parseEdifactDateTime` returns a date-time for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"202406151430"` is a `203` value and not a `204`
+ *   one.
+ * - Checks the calendar as well as the shape: 31 June, 29 February 2023, hour 24 and second 60
+ *   are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "202406151430")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDateTime("202406151430", "203") // true
+ * @example isValidEdifactDateTime("20240615143045", "204") // true
+ * @example isValidEdifactDateTime("202406151430", "204") // false (twelve digits is a 203 value)
+ * @example isValidEdifactDateTime("202302291430", "203") // false (2023 has no 29 February)
+ */
+export declare function isValidEdifactDateTime(value: string, format: EdifactDateTimeFormat): boolean;

package/dist/intermodal/validate/isValidEdifactDateTime.js

@@ -0,0 +1,32 @@
+import { parseEdifactDateTime } from "../parse/parseEdifactDateTime.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * date and time in a format code with no offset (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `203` | `CCYYMMDDHHMM` | "Calendar date including time with minutes" |
+ * | `204` | `CCYYMMDDHHMMSS` | "Calendar date including time with seconds" |
+ *
+ * - True exactly when `parseEdifactDateTime` returns a date-time for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"202406151430"` is a `203` value and not a `204`
+ *   one.
+ * - Checks the calendar as well as the shape: 31 June, 29 February 2023, hour 24 and second 60
+ *   are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "202406151430")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDateTime("202406151430", "203") // true
+ * @example isValidEdifactDateTime("20240615143045", "204") // true
+ * @example isValidEdifactDateTime("202406151430", "204") // false (twelve digits is a 203 value)
+ * @example isValidEdifactDateTime("202302291430", "203") // false (2023 has no 29 February)
+ */
+export function isValidEdifactDateTime(value, format) {
+    return parseEdifactDateTime(value, format) !== "";
+}

package/dist/intermodal/validate/isValidEdifactDateTimePeriod.d.ts

@@ -0,0 +1,28 @@
+import type { EdifactDateTimePeriodFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a period
+ * between two real local date-times, in a date-time period format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `719` | `CCYYMMDDHHMM-CCYYMMDDHHMM` | "A period of time which includes the century, year, month, day, hour and minute. Format of period to be given in actual message without hyphen." |
+ *
+ * - True exactly when `parseEdifactDateTimePeriod` returns a period for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A period is valid in its wire form only, with no hyphen.
+ * - A period whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: hour 24 and 29 February 2023 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "202406151430202406201600")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDateTimePeriod("202406151430202406201600", "719") // true
+ * @example isValidEdifactDateTimePeriod("202406151430-202406201600", "719") // false (a period is transmitted without a hyphen)
+ * @example isValidEdifactDateTimePeriod("202406151431202406151430", "719") // false (the end precedes the start)
+ * @example isValidEdifactDateTimePeriod("202406151430", "719") // false (one date-time)
+ */
+export declare function isValidEdifactDateTimePeriod(value: string, format: EdifactDateTimePeriodFormat): boolean;

package/dist/intermodal/validate/isValidEdifactDateTimePeriod.js

@@ -0,0 +1,30 @@
+import { parseEdifactDateTimePeriod } from "../parse/parseEdifactDateTimePeriod.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a period
+ * between two real local date-times, in a date-time period format code (data element 2379).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `719` | `CCYYMMDDHHMM-CCYYMMDDHHMM` | "A period of time which includes the century, year, month, day, hour and minute. Format of period to be given in actual message without hyphen." |
+ *
+ * - True exactly when `parseEdifactDateTimePeriod` returns a period for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A period is valid in its wire form only, with no hyphen.
+ * - A period whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: hour 24 and 29 February 2023 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "202406151430202406201600")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDateTimePeriod("202406151430202406201600", "719") // true
+ * @example isValidEdifactDateTimePeriod("202406151430-202406201600", "719") // false (a period is transmitted without a hyphen)
+ * @example isValidEdifactDateTimePeriod("202406151431202406151430", "719") // false (the end precedes the start)
+ * @example isValidEdifactDateTimePeriod("202406151430", "719") // false (one date-time)
+ */
+export function isValidEdifactDateTimePeriod(value, format) {
+    return parseEdifactDateTimePeriod(value, format) !== null;
+}

package/dist/intermodal/validate/isValidEdifactDtmFormat.d.ts

@@ -0,0 +1,39 @@
+import type { EdifactDtmFormat } from "../../types/edi.js";
+/**
+ * Return true when `format` is a UN/EDIFACT data element 2379 format code that the EDIFACT
+ * functions read and write.
+ *
+ * - The 11 supported codes are `102` (a date); `401`, `402` (a time); `203`, `204` (a date and
+ *   time with no offset); `205`, `208`, `303`, `304` (a date and time with an offset); `718` (a
+ *   period of dates) and `719` (a period of date-times). `classifyEdifactDtmFormat` names the
+ *   kind of a code, and each kind has its own parser, formatter and validator.
+ * - A code with a two-digit year returns false: `101`, `201`, `202`, `206`, `207`, `301`,
+ *   `302`, `713` and `717`. UN/EDIFACT does not say which century `YY` belongs to; read such a
+ *   value with `parseDateWithPattern` or `parseDateTimeWithPattern`, a `yy` pattern and its
+ *   `yearWindow` option.
+ * - `209` and `404` (a time with an offset and no date) and `406` (an offset alone) return
+ *   false: none names a date, a time, a date-time or an instant.
+ * - Every other 2379 code returns false: the day-first and month-first dates `2`–`5`, `10`
+ *   (`CCYYMMDDTHHMM`), `103`, the ordinal date `105`, `210`, `307`, `308`, the time spans
+ *   `501`–`503`, `711`, the partial values, the weekday period `720` and the quantities (`801`
+ *   and up).
+ * - Matching is exact: `" 203"`, `"0203"` and the number `203` are not codes.
+ * - Accepts any input type and returns false for non-string values.
+ * - A parser returns its sentinel for a code it does not read, the same sentinel it returns for
+ *   a value that does not fit its code. Check the code here to tell an unsupported format apart
+ *   from bad data.
+ *
+ * @param format candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDtmFormat("203") // true
+ * @example isValidEdifactDtmFormat("718") // true
+ * @example isValidEdifactDtmFormat("208") // true
+ * @example isValidEdifactDtmFormat("101") // false (a two-digit year: not read)
+ * @example isValidEdifactDtmFormat("602") // false (a partial value: not supported)
+ * @example isValidEdifactDtmFormat("801") // false (a quantity: not supported)
+ * @example isValidEdifactDtmFormat("0203") // false (matching is exact)
+ * @example isValidEdifactDtmFormat(203) // false (a code is a string)
+ * @example isValidEdifactDtmFormat(null) // false
+ */
+export declare function isValidEdifactDtmFormat(format: unknown): format is EdifactDtmFormat;

package/dist/intermodal/validate/isValidEdifactDtmFormat.js

@@ -0,0 +1,42 @@
+import { EDIFACT_DTM_FORMATS } from "../../internal/index.js";
+/**
+ * Return true when `format` is a UN/EDIFACT data element 2379 format code that the EDIFACT
+ * functions read and write.
+ *
+ * - The 11 supported codes are `102` (a date); `401`, `402` (a time); `203`, `204` (a date and
+ *   time with no offset); `205`, `208`, `303`, `304` (a date and time with an offset); `718` (a
+ *   period of dates) and `719` (a period of date-times). `classifyEdifactDtmFormat` names the
+ *   kind of a code, and each kind has its own parser, formatter and validator.
+ * - A code with a two-digit year returns false: `101`, `201`, `202`, `206`, `207`, `301`,
+ *   `302`, `713` and `717`. UN/EDIFACT does not say which century `YY` belongs to; read such a
+ *   value with `parseDateWithPattern` or `parseDateTimeWithPattern`, a `yy` pattern and its
+ *   `yearWindow` option.
+ * - `209` and `404` (a time with an offset and no date) and `406` (an offset alone) return
+ *   false: none names a date, a time, a date-time or an instant.
+ * - Every other 2379 code returns false: the day-first and month-first dates `2`–`5`, `10`
+ *   (`CCYYMMDDTHHMM`), `103`, the ordinal date `105`, `210`, `307`, `308`, the time spans
+ *   `501`–`503`, `711`, the partial values, the weekday period `720` and the quantities (`801`
+ *   and up).
+ * - Matching is exact: `" 203"`, `"0203"` and the number `203` are not codes.
+ * - Accepts any input type and returns false for non-string values.
+ * - A parser returns its sentinel for a code it does not read, the same sentinel it returns for
+ *   a value that does not fit its code. Check the code here to tell an unsupported format apart
+ *   from bad data.
+ *
+ * @param format candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactDtmFormat("203") // true
+ * @example isValidEdifactDtmFormat("718") // true
+ * @example isValidEdifactDtmFormat("208") // true
+ * @example isValidEdifactDtmFormat("101") // false (a two-digit year: not read)
+ * @example isValidEdifactDtmFormat("602") // false (a partial value: not supported)
+ * @example isValidEdifactDtmFormat("801") // false (a quantity: not supported)
+ * @example isValidEdifactDtmFormat("0203") // false (matching is exact)
+ * @example isValidEdifactDtmFormat(203) // false (a code is a string)
+ * @example isValidEdifactDtmFormat(null) // false
+ */
+export function isValidEdifactDtmFormat(format) {
+    return (typeof format === "string" &&
+        EDIFACT_DTM_FORMATS.includes(format));
+}

package/dist/intermodal/validate/isValidEdifactOffsetDateTime.d.ts

@@ -0,0 +1,36 @@
+import type { EdifactOffsetDateTimeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * date and time with an offset from UTC, in a format code that carries one (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `205` | `CCYYMMDDHHMMZHHMM` | "Calendar date including time and time zone expressed in hours and minutes." |
+ * | `208` | `CCYYMMDDHHMMSSZHHMM` | "Calendar date including time with seconds, with Time Zone" (D.12A and later) |
+ * | `303` | `CCYYMMDDHHMMZZZ` | "See 203 plus Z=Time zone." |
+ * | `304` | `CCYYMMDDHHMMSSZZZ` | "See 204 plus Z=Time zone." |
+ *
+ * - True exactly when `parseEdifactOffsetDateTime` returns a value for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - The three `ZZZ` characters of `303` and `304` are valid only as an offset: a signed hour
+ *   from `00` to `23`, `UTC` or `GMT`. An abbreviation such as `CET`, a broken offset (`+24`)
+ *   and a lone `Z` are false.
+ * - Takes the unescaped element value: `"202406151430?+02"` is false.
+ * - Checks the calendar as well as the shape: 29 February 2023, hour 24 and second 60 are
+ *   false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value, unescaped (e.g. "202406151430+0200")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactOffsetDateTime("202406151430+0200", "205") // true
+ * @example isValidEdifactOffsetDateTime("20240615143045+0530", "208") // true
+ * @example isValidEdifactOffsetDateTime("202406151430UTC", "303") // true
+ * @example isValidEdifactOffsetDateTime("20240615143045-05", "304") // true
+ * @example isValidEdifactOffsetDateTime("202406151430CET", "303") // false (an abbreviation names no offset)
+ * @example isValidEdifactOffsetDateTime("202406151430", "205") // false (no offset)
+ */
+export declare function isValidEdifactOffsetDateTime(value: string, format: EdifactOffsetDateTimeFormat): boolean;

package/dist/intermodal/validate/isValidEdifactOffsetDateTime.js

@@ -0,0 +1,38 @@
+import { parseEdifactOffsetDateTime } from "../parse/parseEdifactOffsetDateTime.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * date and time with an offset from UTC, in a format code that carries one (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `205` | `CCYYMMDDHHMMZHHMM` | "Calendar date including time and time zone expressed in hours and minutes." |
+ * | `208` | `CCYYMMDDHHMMSSZHHMM` | "Calendar date including time with seconds, with Time Zone" (D.12A and later) |
+ * | `303` | `CCYYMMDDHHMMZZZ` | "See 203 plus Z=Time zone." |
+ * | `304` | `CCYYMMDDHHMMSSZZZ` | "See 204 plus Z=Time zone." |
+ *
+ * - True exactly when `parseEdifactOffsetDateTime` returns a value for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - The three `ZZZ` characters of `303` and `304` are valid only as an offset: a signed hour
+ *   from `00` to `23`, `UTC` or `GMT`. An abbreviation such as `CET`, a broken offset (`+24`)
+ *   and a lone `Z` are false.
+ * - Takes the unescaped element value: `"202406151430?+02"` is false.
+ * - Checks the calendar as well as the shape: 29 February 2023, hour 24 and second 60 are
+ *   false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value, unescaped (e.g. "202406151430+0200")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactOffsetDateTime("202406151430+0200", "205") // true
+ * @example isValidEdifactOffsetDateTime("20240615143045+0530", "208") // true
+ * @example isValidEdifactOffsetDateTime("202406151430UTC", "303") // true
+ * @example isValidEdifactOffsetDateTime("20240615143045-05", "304") // true
+ * @example isValidEdifactOffsetDateTime("202406151430CET", "303") // false (an abbreviation names no offset)
+ * @example isValidEdifactOffsetDateTime("202406151430", "205") // false (no offset)
+ */
+export function isValidEdifactOffsetDateTime(value, format) {
+    return parseEdifactOffsetDateTime(value, format) !== "";
+}

package/dist/intermodal/validate/isValidEdifactTime.d.ts

@@ -0,0 +1,28 @@
+import type { EdifactTimeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * time of day in a time format code (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `401` | `HHMM` | "Time without seconds: H = Hour; m = Minute." |
+ * | `402` | `HHMMSS` | "Time with seconds: H = Hour; m = Minute; s = Seconds." |
+ *
+ * - True exactly when `parseEdifactTime` returns a time for the same arguments: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"1430"` is a `401` value and not a `402` one.
+ * - Hour 24, minute 60 and second 60 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "1430")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactTime("1430", "401") // true
+ * @example isValidEdifactTime("143045", "402") // true
+ * @example isValidEdifactTime("1430", "402") // false (four digits is a 401 value)
+ * @example isValidEdifactTime("2400", "401") // false (hour 24)
+ */
+export declare function isValidEdifactTime(value: string, format: EdifactTimeFormat): boolean;

package/dist/intermodal/validate/isValidEdifactTime.js

@@ -0,0 +1,30 @@
+import { parseEdifactTime } from "../parse/parseEdifactTime.js";
+/**
+ * Return true when `value` is a UN/EDIFACT `DTM` value (data element 2380) that states a real
+ * time of day in a time format code (data element 2379).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `401` | `HHMM` | "Time without seconds: H = Hour; m = Minute." |
+ * | `402` | `HHMMSS` | "Time with seconds: H = Hour; m = Minute; s = Seconds." |
+ *
+ * - True exactly when `parseEdifactTime` returns a time for the same arguments: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"1430"` is a `401` value and not a `402` one.
+ * - Hour 24, minute 60 and second 60 are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidEdifactDtmFormat`. False for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "1430")
+ * @param format The data element 2379 format code
+ * @returns boolean indicating validity
+ *
+ * @example isValidEdifactTime("1430", "401") // true
+ * @example isValidEdifactTime("143045", "402") // true
+ * @example isValidEdifactTime("1430", "402") // false (four digits is a 401 value)
+ * @example isValidEdifactTime("2400", "401") // false (hour 24)
+ */
+export function isValidEdifactTime(value, format) {
+    return parseEdifactTime(value, format) !== "";
+}

package/dist/intermodal/validate/isValidEpcisEvent.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Validate whether a value carries the two required time fields of a GS1 EPCIS 2.0 event, each in
+ * the grammar GS1 publishes for it.
+ *
+ * EPCIS (ISO/IEC 19987) is GS1's event standard for supply-chain visibility. True exactly when
+ * `isValidEpcisEventTime` is true of `eventTime` and `isValidEpcisTimeZoneOffset` is true of
+ * `eventTimeZoneOffset`: this validator calls the two, and no check needs both fields at once.
+ * `parseEpcisEvent` returns a result for exactly the same values.
+ *
+ * - `eventTime` must match `epcisEventTime` (the `DateTimeStamp` pattern of the EPCIS XSD, the
+ *   XML binding; the JSON schema says only `format: date-time`) and name a real instant: `YYYY-MM-DDTHH:MM:SS`, an optional fraction of up to nine digits, then
+ *   `Z` or a `±HH:MM` offset. A day the month does not have (`2024-02-30`) is false, although the
+ *   pattern matches it.
+ * - `eventTimeZoneOffset` must match `epcisTimeZoneOffset` (the pattern the EPCIS JSON schema
+ *   gives; the XSD types the field as a bare `xsd:string`): `±HH:MM` from `-14:00` to `+14:00`,
+ *   the rule of EPCIS Standard Release 2.0 §7.4.1 (https://ref.gs1.org/standards/epcis/). A
+ *   missing offset, `Z`, `+0200` and `+02` are false.
+ * - The two fields are independent: an `eventTime` written with one offset and an
+ *   `eventTimeZoneOffset` that is another is valid. EPCIS 2.0 §7.4.1.1 (non-normative): "there
+ *   is no requirement that the time zone specifier in the XML representation of eventTime be the
+ *   local time zone offset where the event was captured".
+ * - **GMT rule:** a fraction longer than nine digits is false. The XSD allows any length; an
+ *   instant holds nanoseconds, and `parseEpcisEvent` does not drop digits.
+ * - Only the two fields are checked. `recordTime` and every other member are ignored, so this
+ *   does not validate a whole event against the EPCIS schema.
+ * - Returns false for a value that is not an object.
+ *
+ * @param event candidate EPCIS event, or any object with `eventTime` and `eventTimeZoneOffset`
+ * @returns boolean indicating whether `parseEpcisEvent` reads the event, or false on invalid input
+ *
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "-05:00" }) // true
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T10:00:00+02:00", eventTimeZoneOffset: "-05:00" }) // true (the two offsets need not agree)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00.123456789Z", eventTimeZoneOffset: "+14:00" }) // true
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z" }) // false (eventTimeZoneOffset is required)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "Z" }) // false (a designator, not an offset)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "+0200" }) // false (no colon)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30Z", eventTimeZoneOffset: "-05:00" }) // false (seconds are required)
+ * @example isValidEpcisEvent({ eventTime: "2024-02-30T14:30:00Z", eventTimeZoneOffset: "-05:00" }) // false (30 February)
+ * @example isValidEpcisEvent("2024-06-15T14:30:00Z") // false (not an event)
+ */
+export declare function isValidEpcisEvent(event: unknown): boolean;

package/dist/intermodal/validate/isValidEpcisEvent.js

@@ -0,0 +1,58 @@
+import { isObject } from "../../internal/index.js";
+import { isValidEpcisEventTime } from "./isValidEpcisEventTime.js";
+import { isValidEpcisTimeZoneOffset } from "./isValidEpcisTimeZoneOffset.js";
+/**
+ * Validate whether a value carries the two required time fields of a GS1 EPCIS 2.0 event, each in
+ * the grammar GS1 publishes for it.
+ *
+ * EPCIS (ISO/IEC 19987) is GS1's event standard for supply-chain visibility. True exactly when
+ * `isValidEpcisEventTime` is true of `eventTime` and `isValidEpcisTimeZoneOffset` is true of
+ * `eventTimeZoneOffset`: this validator calls the two, and no check needs both fields at once.
+ * `parseEpcisEvent` returns a result for exactly the same values.
+ *
+ * - `eventTime` must match `epcisEventTime` (the `DateTimeStamp` pattern of the EPCIS XSD, the
+ *   XML binding; the JSON schema says only `format: date-time`) and name a real instant: `YYYY-MM-DDTHH:MM:SS`, an optional fraction of up to nine digits, then
+ *   `Z` or a `±HH:MM` offset. A day the month does not have (`2024-02-30`) is false, although the
+ *   pattern matches it.
+ * - `eventTimeZoneOffset` must match `epcisTimeZoneOffset` (the pattern the EPCIS JSON schema
+ *   gives; the XSD types the field as a bare `xsd:string`): `±HH:MM` from `-14:00` to `+14:00`,
+ *   the rule of EPCIS Standard Release 2.0 §7.4.1 (https://ref.gs1.org/standards/epcis/). A
+ *   missing offset, `Z`, `+0200` and `+02` are false.
+ * - The two fields are independent: an `eventTime` written with one offset and an
+ *   `eventTimeZoneOffset` that is another is valid. EPCIS 2.0 §7.4.1.1 (non-normative): "there
+ *   is no requirement that the time zone specifier in the XML representation of eventTime be the
+ *   local time zone offset where the event was captured".
+ * - **GMT rule:** a fraction longer than nine digits is false. The XSD allows any length; an
+ *   instant holds nanoseconds, and `parseEpcisEvent` does not drop digits.
+ * - Only the two fields are checked. `recordTime` and every other member are ignored, so this
+ *   does not validate a whole event against the EPCIS schema.
+ * - Returns false for a value that is not an object.
+ *
+ * @param event candidate EPCIS event, or any object with `eventTime` and `eventTimeZoneOffset`
+ * @returns boolean indicating whether `parseEpcisEvent` reads the event, or false on invalid input
+ *
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "-05:00" }) // true
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T10:00:00+02:00", eventTimeZoneOffset: "-05:00" }) // true (the two offsets need not agree)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00.123456789Z", eventTimeZoneOffset: "+14:00" }) // true
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z" }) // false (eventTimeZoneOffset is required)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "Z" }) // false (a designator, not an offset)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30:00Z", eventTimeZoneOffset: "+0200" }) // false (no colon)
+ * @example isValidEpcisEvent({ eventTime: "2024-06-15T14:30Z", eventTimeZoneOffset: "-05:00" }) // false (seconds are required)
+ * @example isValidEpcisEvent({ eventTime: "2024-02-30T14:30:00Z", eventTimeZoneOffset: "-05:00" }) // false (30 February)
+ * @example isValidEpcisEvent("2024-06-15T14:30:00Z") // false (not an event)
+ */
+export function isValidEpcisEvent(event) {
+    try {
+        if (!isObject(event)) {
+            return false;
+        }
+        // Each field is read once, in the order `parseEpcisEvent` reads them.
+        const { eventTime, eventTimeZoneOffset } = event;
+        return (isValidEpcisEventTime(eventTime) &&
+            isValidEpcisTimeZoneOffset(eventTimeZoneOffset));
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile argument is invalid input, not an exception.
+        return false;
+    }
+}