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

package/src/descriptors.ts

@@ -0,0 +1,332 @@
+import { ContentCharacterSets } from "./content-character-set.js";
+import type { GTINDescriptor } from "./gtin-descriptor.js";
+import { type GTINBaseType, GTINTypes } from "./gtin-type.js";
+import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
+import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor.js";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
+import { LeaderTypes, type NumericIdentifierType } from "./numeric-identifier-type.js";
+import { PrefixTypes } from "./prefix-type.js";
+import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor.js";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+
+/**
+ * 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,11 +6,12 @@ import {
     type TransformerOutput
 } from "@aidc-toolkit/utility";
 import { Mixin } from "ts-mixer";
-import { checkDigit, priceOrWeightCheckDigit } from "./check";
-import { type GTINType, GTINTypes, GTINValidator } from "./gtin-validator";
-import { i18nextGS1 } from "./locale/i18n";
-import { AbstractNumericIdentifierCreator } from "./numeric-identifier-creator";
-import type { PrefixProvider } from "./prefix-provider";
+import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
+import { checkDigit, priceOrWeightCheckDigit } from "./check.js";
+import { type GTINBaseType, GTINTypes } from "./gtin-type.js";
+import { GTINValidator } from "./gtin-validator.js";
+import { i18nextGS1 } from "./locale/i18n.js";
+import type { PrefixProvider } from "./prefix-provider.js";
 
 /**
  * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; no applicable to GTIN-14 type.
@@ -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.js";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
+import type { LeaderTypes } from "./numeric-identifier-type.js";
+
+/**
+ * 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.js";
+
+/**
+ * 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. Used to determine the GTIN type supported by a 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,40 +1,12 @@
 import { type CharacterSetValidation, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { checkDigit, hasValidCheckDigit, isValidPriceOrWeightCheckDigit } from "./check";
-import { IdentifierTypes } from "./identifier-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];
+import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator.js";
+import { checkDigit, hasValidCheckDigit, isValidPriceOrWeightCheckDigit } from "./check.js";
+import { IdentifierDescriptors } from "./descriptors.js";
+import type { GTINDescriptor } from "./gtin-descriptor.js";
+import { type GTINBaseType, type GTINType, GTINTypes } from "./gtin-type.js";
+import { i18nextGS1 } from "./locale/i18n.js";
+import { type PrefixType, PrefixTypes } from "./prefix-type.js";
+import { PrefixValidator } from "./prefix-validator.js";
 
 /**
  * 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
 };

package/src/identifier-creator.ts

@@ -1,16 +1,20 @@
-import type { CharacterSetCreator } from "@aidc-toolkit/utility";
-import type { IdentifierType } from "./identifier-type";
-import type { ContentCharacterSet, IdentifierValidation, IdentifierValidator } from "./identifier-validator";
-import type { PrefixProvider } from "./prefix-provider";
-import type { PrefixType } from "./prefix-type";
+import type { IdentifierDescriptor } from "./identifier-descriptor.js";
+import type { IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
+import type { PrefixProvider } from "./prefix-provider.js";
 
 /**
  * Identifier creator. Creates an identifier based on its definition in section 3 of the {@link
- * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
  *
- * Keys are created based on a prefix defined in a prefix manager to which the identifier creator is bound.
+ * Keys are created based on a prefix defined in a prefix provider to which the identifier creator is bound.
+ *
+ * @template TIdentifierDescriptor
+ * Identifier descriptor type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
  */
-export interface IdentifierCreator extends IdentifierValidator {
+export interface IdentifierCreator<TIdentifierDescriptor extends IdentifierDescriptor = IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends IdentifierValidator<TIdentifierDescriptor, TIdentifierValidation> {
     /**
      * Get the prefix provider to which this identifier creator is bound.
      */
@@ -27,71 +31,3 @@ export interface IdentifierCreator extends IdentifierValidator {
      */
     get referenceLength(): number;
 }
-
-/**
- * Abstract identifier creator. Implements common functionality for an identifier creator, bound to a
- * {@link PrefixProvider}.
- */
-export abstract class AbstractIdentifierCreator implements IdentifierCreator {
-    /**
-     * Prefix provider.
-     */
-    private _prefixProvider!: PrefixProvider;
-
-    /**
-     * Reference length.
-     */
-    private _referenceLength!: number;
-
-    /**
-     * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
-     *
-     * @param prefixProvider
-     * Prefix provider.
-     *
-     * @param prefix
-     * Prefix within prefix manager to use to calculate reference length.
-     *
-     * @param checkAllowance
-     * Number of characters to allow for check digit or check character pair.
-     */
-    protected init(prefixProvider: PrefixProvider, prefix: string, checkAllowance: number): void {
-        this._prefixProvider = prefixProvider;
-
-        // Reference length allows for prefix and optionally check digit or check character pair.
-        this._referenceLength = this.length - prefix.length - checkAllowance;
-    }
-
-    abstract get identifierType(): IdentifierType;
-
-    abstract get prefixType(): PrefixType;
-
-    abstract get length(): number;
-
-    abstract get referenceCharacterSet(): ContentCharacterSet;
-
-    abstract get referenceCreator(): CharacterSetCreator;
-
-    /**
-     * @inheritDoc
-     */
-    get prefixProvider(): PrefixProvider {
-        return this._prefixProvider;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    get prefix(): string {
-        return this.prefixProvider.gs1CompanyPrefix;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    get referenceLength(): number {
-        return this._referenceLength;
-    }
-
-    abstract validate(identifier: string, validation?: IdentifierValidation): void;
-}