@aidc-toolkit/gs1 1.0.24-beta → 1.0.25-beta

package/src/creators.ts

@@ -0,0 +1,113 @@
+import {
+    isGTINDescriptor,
+    isNonGTINNumericIdentifierDescriptor,
+    isNonNumericIdentifierDescriptor,
+    isNumericIdentifierDescriptor,
+    isSerializableNumericIdentifierDescriptor
+} from "./descriptors";
+import type { GTINCreator } from "./gtin-creator";
+import type { IdentifierCreator } from "./identifier-creator";
+import type { IdentifierType, IdentifierTypes } from "./identifier-type";
+import type { NonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type";
+import type { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type";
+import type { NumericIdentifierCreator } from "./numeric-identifier-creator";
+import type { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type";
+
+/**
+ * Determine the identifier creator type for an identifier type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeCreator<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
+    NonNumericIdentifierCreator :
+    TIdentifierType extends SerializableNumericIdentifierType ?
+        SerializableNumericIdentifierCreator :
+        TIdentifierType extends NonGTINNumericIdentifierType ?
+            NonGTINNumericIdentifierCreator :
+            TIdentifierType extends typeof IdentifierTypes.GTIN ?
+                GTINCreator :
+                IdentifierCreator;
+
+/**
+ * Identifier creators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierCreatorsEntry<TIdentifierType extends IdentifierType> = IdentifierTypeCreator<TIdentifierType>;
+
+/**
+ * Identifier creators record type.
+ */
+export type IdentifierCreatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierCreatorsEntry<TIdentifierType>;
+};
+
+/**
+ * Determine if identifier creator is a numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a numeric identifier creator.
+ */
+export function isNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NumericIdentifierCreator {
+    return isNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a GTIN creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a GTIN creator.
+ */
+export function isGTINCreator(identifierCreator: IdentifierCreator): identifierCreator is GTINCreator {
+    return isGTINDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-GTIN numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-GTIN numeric identifier creator.
+ */
+export function isNonGTINNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonGTINNumericIdentifierCreator {
+    return isNonGTINNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a serializable numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a serializable numeric identifier creator.
+ */
+export function isSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is SerializableNumericIdentifierCreator {
+    return isSerializableNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-numeric identifier creator.
+ */
+export function isNonNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonNumericIdentifierCreator {
+    return isNonNumericIdentifierDescriptor(identifierCreator);
+}

package/src/descriptors.ts

@@ -0,0 +1,332 @@
+import { ContentCharacterSets } from "./content-character-set";
+import type { GTINDescriptor } from "./gtin-descriptor";
+import { type GTINBaseType, GTINTypes } from "./gtin-type";
+import type { IdentifierDescriptor } from "./identifier-descriptor";
+import { type IdentifierType, IdentifierTypes } from "./identifier-type";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type";
+import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
+import { LeaderTypes, type NumericIdentifierType } from "./numeric-identifier-type";
+import { PrefixTypes } from "./prefix-type";
+import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type";
+
+/**
+ * GTIN-13 descriptor.
+ */
+const GTIN13_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: GTINTypes.GTIN13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN-12 descriptor.
+ */
+const GTIN12_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.UPCCompanyPrefix,
+    length: GTINTypes.GTIN12,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN-8 descriptor.
+ */
+const GTIN8_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.GS18Prefix,
+    length: GTINTypes.GTIN8,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN descriptors indexed by prefix type.
+ */
+const GTIN_DESCRIPTORS: Readonly<Record<GTINBaseType, GTINDescriptor>> = {
+    [GTINTypes.GTIN13]: GTIN13_DESCRIPTOR,
+    [GTINTypes.GTIN12]: GTIN12_DESCRIPTOR,
+    [GTINTypes.GTIN8]: GTIN8_DESCRIPTOR
+};
+
+/**
+ * GLN descriptor.
+ */
+const GLN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GLN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * SSCC descriptor.
+ */
+const SSCC_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.SSCC,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 18,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.ExtensionDigit
+};
+
+/**
+ * GRAI descriptor.
+ */
+const GRAI_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GRAI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 16,
+    serialComponentCharacterSet: ContentCharacterSets.AI82
+};
+
+/**
+ * GIAI descriptor.
+ */
+const GIAI_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GIAI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GSRN descriptor.
+ */
+const GSRN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GSRN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 18,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * GDTI descriptor.
+ */
+const GDTI_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GDTI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 17,
+    serialComponentCharacterSet: ContentCharacterSets.AI82
+};
+
+/**
+ * GINC descriptor.
+ */
+const GINC_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GINC,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GSIN descriptor.
+ */
+const GSIN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GSIN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 17,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * GCN descriptor.
+ */
+const GCN_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GCN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 12,
+    serialComponentCharacterSet: ContentCharacterSets.Numeric
+};
+
+/**
+ * CPID descriptor.
+ */
+const CPID_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.CPID,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI39,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GMN descriptor.
+ */
+const GMN_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GMN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 25,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: true
+};
+
+/**
+ * Identifier descriptor type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
+    NonNumericIdentifierDescriptor :
+    TIdentifierType extends SerializableNumericIdentifierType ?
+        SerializableNumericIdentifierDescriptor :
+        TIdentifierType extends NonGTINNumericIdentifierType ?
+            NonGTINNumericIdentifierDescriptor :
+            TIdentifierType extends typeof IdentifierTypes.GTIN ?
+                GTINDescriptor :
+                IdentifierDescriptor;
+
+/**
+ * Identifier descriptors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ?
+    Readonly<Record<GTINBaseType, GTINDescriptor>> :
+    IdentifierTypeDescriptor<TIdentifierType>;
+
+/**
+ * Identifier descriptors record type.
+ */
+export type IdentifierDescriptorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
+};
+
+/**
+ * Identifier descriptors for all identifier types.
+ */
+export const IdentifierDescriptors: IdentifierDescriptorsRecord = {
+    [IdentifierTypes.GTIN]: GTIN_DESCRIPTORS,
+    [IdentifierTypes.GLN]: GLN_DESCRIPTOR,
+    [IdentifierTypes.SSCC]: SSCC_DESCRIPTOR,
+    [IdentifierTypes.GRAI]: GRAI_DESCRIPTOR,
+    [IdentifierTypes.GIAI]: GIAI_DESCRIPTOR,
+    [IdentifierTypes.GSRN]: GSRN_DESCRIPTOR,
+    [IdentifierTypes.GDTI]: GDTI_DESCRIPTOR,
+    [IdentifierTypes.GINC]: GINC_DESCRIPTOR,
+    [IdentifierTypes.GSIN]: GSIN_DESCRIPTOR,
+    [IdentifierTypes.GCN]: GCN_DESCRIPTOR,
+    [IdentifierTypes.CPID]: CPID_DESCRIPTOR,
+    [IdentifierTypes.GMN]: GMN_DESCRIPTOR
+} as const;
+
+/**
+ * Determine if identifier descriptors or descriptor is GTIN descriptors.
+ *
+ * @param identifierDescriptorsOrDescriptor
+ * Identifier descriptors or descriptor.
+ *
+ * @returns
+ * True if GTIN descriptors.
+ */
+export function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseType, GTINDescriptor>> {
+    return !("identifierType" in identifierDescriptorsOrDescriptor);
+}
+
+/**
+ * Determine if an array of identifier types includes a given identifier type.
+ *
+ * @param identifierTypes
+ * Identifier types.
+ *
+ * @param identifierType
+ * Identifier type.
+ *
+ * @returns
+ * True if element is included in the array.
+ */
+function identifierTypesIncludes(identifierTypes: readonly IdentifierType[], identifierType: IdentifierType): boolean {
+    return identifierTypes.includes(identifierType);
+}
+
+const NUMERIC_IDENTIFIER_TYPES: readonly NumericIdentifierType[] = [IdentifierTypes.GTIN, IdentifierTypes.GLN, IdentifierTypes.SSCC, IdentifierTypes.GRAI, IdentifierTypes.GSRN, IdentifierTypes.GDTI, IdentifierTypes.GSIN, IdentifierTypes.GCN];
+
+/**
+ * Determine if identifier descriptor is a numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a numeric identifier descriptor.
+ */
+export function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NumericIdentifierDescriptor {
+    return identifierTypesIncludes(NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+}
+
+/**
+ * Determine if identifier descriptor is a GTIN descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a GTIN descriptor.
+ */
+export function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is GTINDescriptor {
+    return identifierDescriptor.identifierType === IdentifierTypes.GTIN;
+}
+
+/**
+ * Determine if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ */
+export function isNonGTINNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonGTINNumericIdentifierDescriptor {
+    return isNumericIdentifierDescriptor(identifierDescriptor) && !isGTINDescriptor(identifierDescriptor);
+}
+
+const SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES: readonly SerializableNumericIdentifierType[] = [IdentifierTypes.GRAI, IdentifierTypes.GDTI, IdentifierTypes.GCN];
+
+/**
+ * Determine if identifier descriptor is a serializable numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a serializable numeric identifier descriptor.
+ */
+export function isSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is SerializableNumericIdentifierDescriptor {
+    return identifierTypesIncludes(SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+}
+
+/**
+ * Determine if identifier descriptor is a non-numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-numeric identifier descriptor.
+ */
+export function isNonNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonNumericIdentifierDescriptor {
+    return !isNumericIdentifierDescriptor(identifierDescriptor);
+}

package/src/gtin-creator.ts

@@ -6,10 +6,11 @@ import {
     type TransformerOutput
 } from "@aidc-toolkit/utility";
 import { Mixin } from "ts-mixer";
+import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator";
 import { checkDigit, priceOrWeightCheckDigit } from "./check";
-import { type GTINType, GTINTypes, GTINValidator } from "./gtin-validator";
+import { type GTINBaseType, GTINTypes } from "./gtin-type";
+import { GTINValidator } from "./gtin-validator";
 import { i18nextGS1 } from "./locale/i18n";
-import { AbstractNumericIdentifierCreator } from "./numeric-identifier-creator";
 import type { PrefixProvider } from "./prefix-provider";
 
 /**
@@ -32,11 +33,11 @@ export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentifierC
      * @param prefixProvider
      * Prefix provider.
      *
-     * @param gtinType
-     * GTIN type.
+     * @param gtinBaseType
+     * GTIN base type (all except GTIN-14).
      */
-    constructor(prefixProvider: PrefixProvider, gtinType: GTINType) {
-        super(gtinType);
+    constructor(prefixProvider: PrefixProvider, gtinBaseType: GTINBaseType) {
+        super(gtinBaseType);
 
         this.init(prefixProvider, prefixProvider.prefix);
     }

package/src/gtin-descriptor.ts

@@ -0,0 +1,18 @@
+import type { IdentifierTypes } from "./identifier-type";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
+import type { LeaderTypes } from "./numeric-identifier-type";
+
+/**
+ * GTIN descriptor.
+ */
+export interface GTINDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: typeof IdentifierTypes.GTIN;
+
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.IndicatorDigit;
+}

package/src/gtin-type.ts

@@ -0,0 +1,50 @@
+import { type PrefixType, PrefixTypes } from "./prefix-type";
+
+/**
+ * GTIN types. The numeric values are equal to the lengths of the GTIN types.
+ */
+export const GTINTypes = {
+    /**
+     * GTIN-13.
+     */
+    GTIN13: 13,
+
+    /**
+     * GTIN-12.
+     */
+    GTIN12: 12,
+
+    /**
+     * GTIN-8.
+     */
+    GTIN8: 8,
+
+    /**
+     * GTIN-14.
+     */
+    GTIN14: 14
+} as const;
+
+/**
+ * GTIN type key.
+ */
+export type GTINTypeKey = keyof typeof GTINTypes;
+
+/**
+ * GTIN type.
+ */
+export type GTINType = typeof GTINTypes[GTINTypeKey];
+
+/**
+ * GTIN base type (all except GTIN-14).
+ */
+export type GTINBaseType = Exclude<GTINType, typeof GTINTypes.GTIN14>;
+
+/**
+ * GTIN base types by prefix type.
+ */
+export const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseType>> = {
+    [PrefixTypes.GS1CompanyPrefix]: GTINTypes.GTIN13,
+    [PrefixTypes.UPCCompanyPrefix]: GTINTypes.GTIN12,
+    [PrefixTypes.GS18Prefix]: GTINTypes.GTIN8
+};

package/src/gtin-validator.ts

@@ -1,41 +1,13 @@
 import { type CharacterSetValidation, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
+import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator";
 import { checkDigit, hasValidCheckDigit, isValidPriceOrWeightCheckDigit } from "./check";
-import { IdentifierTypes } from "./identifier-type";
+import { IdentifierDescriptors } from "./descriptors";
+import type { GTINDescriptor } from "./gtin-descriptor";
+import { type GTINBaseType, type GTINType, GTINTypes } from "./gtin-type";
 import { i18nextGS1 } from "./locale/i18n";
-import { AbstractNumericIdentifierValidator, LeaderTypes } from "./numeric-identifier-validator";
 import { type PrefixType, PrefixTypes } from "./prefix-type";
 import { PrefixValidator } from "./prefix-validator";
 
-/**
- * GTIN types. The numeric values are equal to the lengths of the GTIN types.
- */
-export const GTINTypes = {
-    /**
-     * GTIN-13.
-     */
-    GTIN13: 13,
-
-    /**
-     * GTIN-12.
-     */
-    GTIN12: 12,
-
-    /**
-     * GTIN-8.
-     */
-    GTIN8: 8,
-
-    /**
-     * GTIN-14.
-     */
-    GTIN14: 14
-} as const;
-
-/**
- * GTIN type.
- */
-export type GTINType = typeof GTINTypes[keyof typeof GTINTypes];
-
 /**
  * Levels at which GTIN is to be validated.
  */
@@ -56,10 +28,15 @@ export const GTINLevels = {
     OtherThanRetailConsumer: 2
 } as const;
 
+/**
+ * GTIN level key.
+ */
+export type GTINLevelKey = keyof typeof GTINLevels;
+
 /**
  * GTIN level.
  */
-export type GTINLevel = typeof GTINLevels[keyof typeof GTINLevels];
+export type GTINLevel = typeof GTINLevels[GTINLevelKey];
 
 /**
  * Restricted Circulation Number reference.
@@ -79,7 +56,7 @@ export interface RCNReference {
 /**
  * GTIN validator.
  */
-export class GTINValidator extends AbstractNumericIdentifierValidator {
+export class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescriptor> {
     /**
      * Validation parameters for optional indicator digit.
      */
@@ -97,35 +74,30 @@ export class GTINValidator extends AbstractNumericIdentifierValidator {
         maximumLength: 8
     };
 
+    /**
+     * Prefix type.
+     */
+    private readonly _prefixType: PrefixType;
+
     /**
      * Constructor.
      *
-     * @param gtinType
-     * GTIN type.
+     * @param gtinBaseType
+     * GTIN base type (all except GTIN-14).
      */
-    constructor(gtinType: GTINType) {
-        let prefixType: PrefixType;
-
-        // Determine the prefix type based on the GTIN type.
-        switch (gtinType) {
-            case GTINTypes.GTIN13:
-                prefixType = PrefixTypes.GS1CompanyPrefix;
-                break;
+    constructor(gtinBaseType: GTINBaseType) {
+        const identifierDescriptor = IdentifierDescriptors.GTIN[gtinBaseType];
 
-            case GTINTypes.GTIN12:
-                prefixType = PrefixTypes.UPCCompanyPrefix;
-                break;
-
-            case GTINTypes.GTIN8:
-                prefixType = PrefixTypes.GS18Prefix;
-                break;
+        super(identifierDescriptor);
 
-            default:
-                // Should never get here.
-                throw new Error("Not supported");
-        }
+        this._prefixType = identifierDescriptor.prefixType;
+    }
 
-        super(IdentifierTypes.GTIN, prefixType, gtinType, LeaderTypes.IndicatorDigit);
+    /**
+     * @inheritDoc
+     */
+    override get prefixType(): PrefixType {
+        return this._prefixType;
     }
 
     /**
@@ -542,23 +514,27 @@ export class GTINValidator extends AbstractNumericIdentifierValidator {
 /**
  * GTIN-13 validator.
  */
+// Defined here because of circular reference.
 export const GTIN13_VALIDATOR = new GTINValidator(GTINTypes.GTIN13);
 
 /**
  * GTIN-12 validator.
  */
+// Defined here because of circular reference.
 export const GTIN12_VALIDATOR = new GTINValidator(GTINTypes.GTIN12);
 
 /**
  * GTIN-8 validator.
  */
+// Defined here because of circular reference.
 export const GTIN8_VALIDATOR = new GTINValidator(GTINTypes.GTIN8);
 
 /**
  * GTIN validators indexed by prefix type.
  */
-export const GTIN_VALIDATORS: Record<PrefixType, GTINValidator> = {
-    [PrefixTypes.GS1CompanyPrefix]: GTIN13_VALIDATOR,
-    [PrefixTypes.UPCCompanyPrefix]: GTIN12_VALIDATOR,
-    [PrefixTypes.GS18Prefix]: GTIN8_VALIDATOR
+// Defined here because of circular reference.
+export const GTIN_VALIDATORS: Readonly<Record<GTINBaseType, GTINValidator>> = {
+    [GTINTypes.GTIN13]: GTIN13_VALIDATOR,
+    [GTINTypes.GTIN12]: GTIN12_VALIDATOR,
+    [GTINTypes.GTIN8]: GTIN8_VALIDATOR
 };