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

package/dist/index.d.ts

@@ -35,7 +35,6 @@ declare const _default: {
         readonly gs1CompanyPrefix: "GS1 Company Prefix";
         readonly upcCompanyPrefix: "U.P.C. Company Prefix";
         readonly gs18Prefix: "GS1-8 Prefix";
-        readonly invalidPrefixType: "Invalid prefix type";
         readonly gs1CompanyPrefixCantStartWith0: "GS1 Company Prefix can't start with \"0\"";
         readonly gs1CompanyPrefixCantStartWith00000: "GS1 Company Prefix can't start with \"00000\"";
         readonly gs1CompanyPrefixCantStartWith000000: "GS1 Company Prefix can't start with \"000000\"";
@@ -70,34 +69,34 @@ declare const i18nextGS1: i18n;
 declare function i18nGS1Init(environment: I18nEnvironment, debug?: boolean): Promise<void>;
 
 /**
- * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
  */
 declare const AI82_CREATOR: CharacterSetCreator;
 /**
- * GS1 AI encodable character set 82 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ * GS1 AI encodable character set 82 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
  */
 declare const AI82_VALIDATOR: CharacterSetValidator;
 /**
- * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
  */
 declare const AI39_CREATOR: CharacterSetCreator;
 /**
- * GS1 AI encodable character set 39 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
+ * GS1 AI encodable character set 39 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
  */
 declare const AI39_VALIDATOR: CharacterSetValidator;
 /**
- * GS1 AI encodable character set 64 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Doesn't support any exclusions.
+ * GS1 AI encodable character set 64 validator as defined in section 7.11 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}. Doesn't support any exclusions.
  */
 declare const AI64_VALIDATOR: CharacterSetValidator;
 
 /**
- * Calculate the check digit sum for a numeric string as per section 7.9.1 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}.
+ * Calculate the check digit sum for a numeric string as per section 7.9.1 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
  *
  * @param exchangeWeights
  * If true, start the weights at 1 instead of 3 on the right.
@@ -110,8 +109,8 @@ declare const AI64_VALIDATOR: CharacterSetValidator;
  */
 declare function checkDigitSum(exchangeWeights: boolean, s: string): number;
 /**
- * Calculate the check digit for a numeric string as per section 7.9.1 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}.
+ * Calculate the check digit for a numeric string as per section 7.9.1 of the {@link
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
  *
  * @param s
  * Numeric string.
@@ -131,8 +130,8 @@ declare function checkDigit(s: string): string;
  */
 declare function hasValidCheckDigit(s: string): boolean;
 /**
- * Calculate the price or weight check digit for a four-or five-digit numeric string as per section 7.9.3 of the {@link
- * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ * Calculate the price or weight check digit for a four-or five-digit numeric string as per sections 7.9.2-7.9.4 of the
+ * {@link https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
  *
  * @param s
  * Numeric string exactly four or five characters long.
@@ -156,7 +155,7 @@ declare function priceOrWeightCheckDigit(s: string): string;
 declare function isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): boolean;
 /**
  * Calculate the check character for a GS1 AI encodable character set 82 string as per section 7.9.5 of the {@link
- * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ * https://ref.gs1.org/standards/genspecs/ | GS1 General Specifications}.
  *
  * @param s
  * GS1 AI encodable character set 82 string.
@@ -193,10 +192,40 @@ declare const PrefixTypes: {
      */
     readonly GS18Prefix: "GS1-8 Prefix";
 };
+/**
+ * Prefix type key.
+ */
+type PrefixTypeKey = keyof typeof PrefixTypes;
 /**
  * Prefix type.
  */
-type PrefixType = typeof PrefixTypes[keyof typeof PrefixTypes];
+type PrefixType = typeof PrefixTypes[PrefixTypeKey];
+
+/**
+ * Prefix provider.
+ */
+interface PrefixProvider {
+    /**
+     * Prefix type.
+     */
+    readonly prefixType: PrefixType;
+    /**
+     * Prefix appropriate to the prefix type.
+     */
+    readonly prefix: string;
+    /**
+     * Prefix as GS1 Company Prefix.
+     */
+    readonly gs1CompanyPrefix: string;
+    /**
+     * Prefix as U.P.C. Company Prefix if prefix type is {@linkcode PrefixTypes.UPCCompanyPrefix} or undefined if not.
+     */
+    readonly upcCompanyPrefix: string | undefined;
+    /**
+     * Prefix as GS1-8 Prefix if prefix type is {@linkcode PrefixTypes.GS18Prefix} or undefined if not.
+     */
+    readonly gs18Prefix: string | undefined;
+}
 
 /**
  * Prefix validation parameters.
@@ -215,31 +244,6 @@ interface PrefixValidation extends CharacterSetValidation {
      */
     component: () => string;
 }
-/**
- * Validate a prefix.
- *
- * @param prefixType
- * Prefix type.
- *
- * @param allowUPCCompanyPrefix
- * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
- *
- * @param allowGS18Prefix
- * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
- *
- * @param prefix
- * Prefix.
- *
- * @param isFromIdentifier
- * If true, the prefix is from an identifier and should be trimmed before its character set is validated.
- *
- * @param isNumericIdentifier
- * If true, the prefix is from a numeric identifier and its character set will be validated by the caller.
- *
- * @param positionOffset
- * Position offset within a larger string.
- */
-declare function validate(prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentifier?: boolean, isNumericIdentifier?: boolean, positionOffset?: number): void;
 /**
  * Prefix validator.
  */
@@ -250,8 +254,71 @@ declare const PrefixValidator: {
     readonly UPC_COMPANY_PREFIX_MAXIMUM_LENGTH: 11;
     readonly GS1_8_PREFIX_MINIMUM_LENGTH: 2;
     readonly GS1_8_PREFIX_MAXIMUM_LENGTH: 7;
-    readonly validate: typeof validate;
+    /**
+     * Validate a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param allowUPCCompanyPrefix
+     * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param allowGS18Prefix
+     * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @param isFromIdentifier
+     * If true, the prefix is from an identifier and should be trimmed before its character set is validated.
+     *
+     * @param isNumericIdentifier
+     * If true, the prefix is from a numeric identifier and its character set will be validated by the caller.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    readonly validate: (prefixType: PrefixType, allowUPCCompanyPrefix: boolean, allowGS18Prefix: boolean, prefix: string, isFromIdentifier?: boolean, isNumericIdentifier?: boolean, positionOffset?: number) => void;
+    /**
+     * Normalize a prefix.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @returns
+     * Prefix provider with normalized prefix type and prefix.
+     */
+    readonly normalize: (prefixType: PrefixType, prefix: string) => PrefixProvider;
+};
+
+/**
+ * Character sets supported by the reference portion of an identifier or the serial component of a numeric identifier.
+ */
+declare const ContentCharacterSets: {
+    /**
+     * Numeric.
+     */
+    readonly Numeric: "Numeric";
+    /**
+     * GS1 AI encodable character set 82.
+     */
+    readonly AI82: "AI82";
+    /**
+     * GS1 AI encodable character set 39.
+     */
+    readonly AI39: "AI39";
 };
+/**
+ * Content character set key.
+ */
+type ContentCharacterSetKey = keyof typeof ContentCharacterSets;
+/**
+ * Content character set.
+ */
+type ContentCharacterSet = typeof ContentCharacterSets[ContentCharacterSetKey];
 
 /**
  * Identifier types.
@@ -306,60 +373,327 @@ declare const IdentifierTypes: {
      */
     readonly GMN: "GMN";
 };
+/**
+ * Identifier type key.
+ */
+type IdentifierTypeKey = keyof typeof IdentifierTypes;
 /**
  * Identifier type.
  */
-type IdentifierType = typeof IdentifierTypes[keyof typeof IdentifierTypes];
+type IdentifierType = typeof IdentifierTypes[IdentifierTypeKey];
 
 /**
- * Character sets supported by the reference portion of an identifier or the serial component of a numeric identifier.
+ * Numeric identifier type.
  */
-declare const ContentCharacterSets: {
+type NumericIdentifierType = typeof IdentifierTypes.GTIN | typeof IdentifierTypes.GLN | typeof IdentifierTypes.SSCC | typeof IdentifierTypes.GRAI | typeof IdentifierTypes.GSRN | typeof IdentifierTypes.GDTI | typeof IdentifierTypes.GSIN | typeof IdentifierTypes.GCN;
+/**
+ * Leader type.
+ */
+declare const LeaderTypes: {
     /**
-     * Numeric.
+     * No leader.
      */
-    readonly Numeric: "Numeric";
+    readonly None: "None";
     /**
-     * GS1 AI encodable character set 82.
+     * Indicator digit (GTIN only).
      */
-    readonly AI82: "AI82";
+    readonly IndicatorDigit: "Indicator digit";
     /**
-     * GS1 AI encodable character set 39.
+     * Extension digit (SSCC only).
      */
-    readonly AI39: "AI39";
+    readonly ExtensionDigit: "Extension digit";
 };
 /**
- * Content character set.
+ * Leader type key.
  */
-type ContentCharacterSet = typeof ContentCharacterSets[keyof typeof ContentCharacterSets];
+type LeaderTypeKey = keyof typeof LeaderTypes;
 /**
- * Identifier validation parameters.
+ * Leader type.
  */
-interface IdentifierValidation extends StringValidation {
+type LeaderType = typeof LeaderTypes[LeaderTypeKey];
+
+/**
+ * GTIN types. The numeric values are equal to the lengths of the GTIN types.
+ */
+declare const GTINTypes: {
     /**
-     * Position offset within a larger string. Strings are sometimes composed of multiple substrings; this parameter
-     * ensures that the error notes the proper position in the string.
+     * GTIN-13.
      */
-    positionOffset?: number | undefined;
+    readonly GTIN13: 13;
+    /**
+     * GTIN-12.
+     */
+    readonly GTIN12: 12;
+    /**
+     * GTIN-8.
+     */
+    readonly GTIN8: 8;
+    /**
+     * GTIN-14.
+     */
+    readonly GTIN14: 14;
+};
+/**
+ * GTIN type key.
+ */
+type GTINTypeKey = keyof typeof GTINTypes;
+/**
+ * GTIN type.
+ */
+type GTINType = typeof GTINTypes[GTINTypeKey];
+/**
+ * GTIN base type (all except GTIN-14).
+ */
+type GTINBaseType = Exclude<GTINType, typeof GTINTypes.GTIN14>;
+/**
+ * GTIN base types by prefix type.
+ */
+declare const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseType>>;
+
+/**
+ * Non-GTIN numeric identifier type.
+ */
+type NonGTINNumericIdentifierType = Exclude<NumericIdentifierType, typeof IdentifierTypes.GTIN>;
+
+/**
+ * Serializable numeric identifier type.
+ */
+type SerializableNumericIdentifierType = typeof IdentifierTypes.GRAI | typeof IdentifierTypes.GDTI | typeof IdentifierTypes.GCN;
+
+/**
+ * Non-numeric identifier type.
+ */
+type NonNumericIdentifierType = Exclude<IdentifierType, NumericIdentifierType>;
+
+/**
+ * Identifier descriptor. Instantiations of this type are used to parameterize validators and creators.
+ */
+interface IdentifierDescriptor {
+    /**
+     * Identifier type. Per the GS1 General Specifications, the identifier type determines the remaining properties.
+     */
+    readonly identifierType: IdentifierType;
+    /**
+     * Prefix type supported by the identifier type. For all identifier types except the GTIN, this is a GS1 Company
+     * Prefix. For the GTIN, the prefix type determines the length.
+     */
+    readonly prefixType: PrefixType;
+    /**
+     * Length. For numeric identifier types, the length is fixed; for non-numeric identifier types, the length is the
+     * maximum.
+     */
+    readonly length: number;
+    /**
+     * Reference character set.
+     */
+    readonly referenceCharacterSet: ContentCharacterSet;
+}
+
+/**
+ * Numeric identifier descriptor.
+ */
+interface NumericIdentifierDescriptor extends IdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly referenceCharacterSet: typeof ContentCharacterSets.Numeric;
+    /**
+     * Leader type.
+     */
+    readonly leaderType: LeaderType;
+}
+
+/**
+ * GTIN descriptor.
+ */
+interface GTINDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: typeof IdentifierTypes.GTIN;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.IndicatorDigit;
+}
+
+/**
+ * Non-GTIN numeric identifier descriptor.
+ */
+interface NonGTINNumericIdentifierDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NonGTINNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly prefixType: typeof PrefixTypes.GS1CompanyPrefix;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: Exclude<LeaderType, typeof LeaderTypes.IndicatorDigit>;
+}
+
+/**
+ * Serializable numeric identifier descriptor.
+ */
+interface SerializableNumericIdentifierDescriptor extends NonGTINNumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: SerializableNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.None;
+    /**
+     * Serial component length.
+     */
+    readonly serialComponentLength: number;
+    /**
+     * Serial component character set.
+     */
+    readonly serialComponentCharacterSet: ContentCharacterSet;
+}
+
+/**
+ * Non-numeric identifier descriptor.
+ */
+interface NonNumericIdentifierDescriptor extends IdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NonNumericIdentifierType;
+    /**
+     * @inheritDoc
+     */
+    readonly prefixType: typeof PrefixTypes.GS1CompanyPrefix;
+    /**
+     * @inheritDoc
+     */
+    readonly referenceCharacterSet: Exclude<ContentCharacterSet, typeof ContentCharacterSets.Numeric>;
+    /**
+     * True if identifier requires a check character pair.
+     */
+    readonly requiresCheckCharacterPair: boolean;
+}
+
+/**
+ * Identifier descriptor type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+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.
+ */
+type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ? Readonly<Record<GTINBaseType, GTINDescriptor>> : IdentifierTypeDescriptor<TIdentifierType>;
+/**
+ * Identifier descriptors record type.
+ */
+type IdentifierDescriptorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
+};
+/**
+ * Identifier descriptors for all identifier types.
+ */
+declare const IdentifierDescriptors: IdentifierDescriptorsRecord;
+/**
+ * Determine if identifier descriptors or descriptor is GTIN descriptors.
+ *
+ * @param identifierDescriptorsOrDescriptor
+ * Identifier descriptors or descriptor.
+ *
+ * @returns
+ * True if GTIN descriptors.
+ */
+declare function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseType, GTINDescriptor>>;
+/**
+ * Determine if identifier descriptor is a numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a numeric identifier descriptor.
+ */
+declare function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NumericIdentifierDescriptor;
+/**
+ * Determine if identifier descriptor is a GTIN descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a GTIN descriptor.
+ */
+declare function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is GTINDescriptor;
+/**
+ * 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.
+ */
+declare function isNonGTINNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonGTINNumericIdentifierDescriptor;
+/**
+ * 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.
+ */
+declare function isSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is SerializableNumericIdentifierDescriptor;
+/**
+ * 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.
+ */
+declare function isNonNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonNumericIdentifierDescriptor;
+
+/**
+ * Identifier validation parameters.
+ */
+interface IdentifierValidation extends StringValidation {
 }
 /**
  * Identifier validator. Validates an identifier against 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}.
+ *
+ * @template TIdentifierDescriptor
+ * Identifier descriptor type.
  *
  * @template TIdentifierValidation
  * Identifier validation type.
  */
-interface IdentifierValidator<TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends StringValidator<TIdentifierValidation> {
+interface IdentifierValidator<TIdentifierDescriptor extends IdentifierDescriptor = IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation = IdentifierValidation> extends StringValidator<TIdentifierValidation> {
     /**
      * Get the identifier type. Per the GS1 General Specifications, the identifier type determines the remaining
      * properties.
      */
-    get identifierType(): IdentifierType;
+    get identifierType(): TIdentifierDescriptor["identifierType"];
     /**
-     * Get the prefix type supported by the identifier type. For all identifier types except the GTIN, this is
-     * {@linkcode PrefixTypes.GS1CompanyPrefix}. For the GTIN, the prefix type determines the length.
+     * Get the prefix type supported by the identifier type. For all identifier types except the GTIN, this is a GS1
+     * Company Prefix. For the GTIN, the prefix type determines the length.
      */
-    get prefixType(): PrefixType;
+    get prefixType(): TIdentifierDescriptor["prefixType"];
     /**
      * Get the length. For numeric identifier types, the length is fixed; for alphanumeric identifier types, the length
      * is the maximum.
@@ -368,7 +702,7 @@ interface IdentifierValidator<TIdentifierValidation extends IdentifierValidation
     /**
      * Get the reference character set.
      */
-    get referenceCharacterSet(): ContentCharacterSet;
+    get referenceCharacterSet(): TIdentifierDescriptor["referenceCharacterSet"];
     /**
      * Get the reference creator.
      */
@@ -384,19 +718,44 @@ interface IdentifierValidator<TIdentifierValidation extends IdentifierValidation
      */
     validate: (identifier: string, validation?: TIdentifierValidation) => void;
 }
+
+/**
+ * Numeric identifier validation parameters.
+ */
+interface NumericIdentifierValidation extends IdentifierValidation {
+    /**
+     * Position offset within a larger string. Some numeric identifier types have the prefix offset by one.
+     */
+    positionOffset?: number | undefined;
+}
+/**
+ * Numeric identifier validator.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
+ */
+interface NumericIdentifierValidator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends IdentifierValidator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
+    /**
+     * Get the leader type.
+     */
+    get leaderType(): TNumericIdentifierDescriptor["leaderType"];
+}
+
 /**
  * Abstract identifier validator. Implements common functionality for an identifier validator.
+ *
+ * @template TIdentifierDescriptor
+ * Identifier descriptor type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
  */
-declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends IdentifierValidation = IdentifierValidation> implements IdentifierValidator<TIdentifierValidation> {
+declare abstract class AbstractIdentifierValidator<TIdentifierDescriptor extends IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation> implements IdentifierValidator<TIdentifierDescriptor, TIdentifierValidation> {
     private static readonly CHARACTER_SET_CREATORS;
     /**
      * Identifier type.
      */
     private readonly _identifierType;
-    /**
-     * Prefix type.
-     */
-    private readonly _prefixType;
     /**
      * Length.
      */
@@ -422,27 +781,18 @@ declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends
     /**
      * Constructor.
      *
-     * @param identifierType
-     * Identifier type.
-     *
-     * @param prefixType
-     * Prefix type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param referenceCharacterSet
-     * Reference character set.
+     * @param identifierDescriptor
+     * Identifier descriptor.
      */
-    protected constructor(identifierType: IdentifierType, prefixType: PrefixType, length: number, referenceCharacterSet: ContentCharacterSet);
+    protected constructor(identifierDescriptor: IdentifierDescriptor);
     /**
      * @inheritDoc
      */
-    get identifierType(): IdentifierType;
+    get identifierType(): TIdentifierDescriptor["identifierType"];
     /**
      * @inheritDoc
      */
-    get prefixType(): PrefixType;
+    get prefixType(): TIdentifierDescriptor["prefixType"];
     /**
      * @inheritDoc
      */
@@ -450,7 +800,7 @@ declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends
     /**
      * @inheritDoc
      */
-    get referenceCharacterSet(): ContentCharacterSet;
+    get referenceCharacterSet(): TIdentifierDescriptor["referenceCharacterSet"];
     /**
      * @inheritDoc
      */
@@ -462,13 +812,13 @@ declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends
      * @param identifier
      * Identifier.
      *
-     * @param validation
-     * Identifier validation parameters.
+     * @param positionOffset
+     * Position offset within a larger string.
      *
      * @returns
      * Padded identifier.
      */
-    protected padIdentifier(identifier: string, validation: IdentifierValidation | undefined): string;
+    protected padIdentifier(identifier: string, positionOffset?: number): string;
     /**
      * Validate the prefix within an identifier.
      *
@@ -483,44 +833,12 @@ declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends
 }
 
 /**
- * Numeric identifier type.
- */
-type NumericIdentifierType = typeof IdentifierTypes.GTIN | typeof IdentifierTypes.GLN | typeof IdentifierTypes.SSCC | typeof IdentifierTypes.GRAI | typeof IdentifierTypes.GSRN | typeof IdentifierTypes.GDTI | typeof IdentifierTypes.GSIN | typeof IdentifierTypes.GCN;
-/**
- * Leader type.
- */
-declare const LeaderTypes: {
-    /**
-     * No leader.
-     */
-    None: string;
-    /**
-     * Indicator digit (GTIN only).
-     */
-    IndicatorDigit: string;
-    /**
-     * Extension digit (SSCC only).
-     */
-    ExtensionDigit: string;
-};
-/**
- * Leader type.
- */
-type LeaderType = typeof LeaderTypes[keyof typeof LeaderTypes];
-/**
- * Numeric identifier validator. Validates a numeric identifier.
- */
-interface NumericIdentifierValidator extends IdentifierValidator {
-    /**
-     * Get the leader type.
-     */
-    get leaderType(): LeaderType;
-}
-/**
- * Abstract numeric identifier validator. Implements common functionality for a numeric identifier
- * validator.
+ * Abstract numeric identifier validator.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
  */
-declare abstract class AbstractNumericIdentifierValidator extends AbstractIdentifierValidator implements NumericIdentifierValidator {
+declare abstract class AbstractNumericIdentifierValidator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor> extends AbstractIdentifierValidator<TNumericIdentifierDescriptor, NumericIdentifierValidation> implements NumericIdentifierValidator<TNumericIdentifierDescriptor> {
     /**
      * Leader type.
      */
@@ -532,54 +850,20 @@ declare abstract class AbstractNumericIdentifierValidator extends AbstractIdenti
     /**
      * Constructor.
      *
-     * @param identifierType
-     * Identifier type.
-     *
-     * @param prefixType
-     * Prefix type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param leaderType
-     * Leader type.
+     * @param identifierDescriptor
+     * Identifier descriptor.
      */
-    protected constructor(identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType);
+    constructor(identifierDescriptor: NumericIdentifierDescriptor);
     /**
      * @inheritDoc
      */
-    get leaderType(): LeaderType;
+    get leaderType(): TNumericIdentifierDescriptor["leaderType"];
     /**
      * @inheritDoc
      */
-    validate(identifier: string, validation?: IdentifierValidation): void;
+    validate(identifier: string, validation?: NumericIdentifierValidation): void;
 }
 
-/**
- * GTIN types. The numeric values are equal to the lengths of the GTIN types.
- */
-declare const GTINTypes: {
-    /**
-     * GTIN-13.
-     */
-    readonly GTIN13: 13;
-    /**
-     * GTIN-12.
-     */
-    readonly GTIN12: 12;
-    /**
-     * GTIN-8.
-     */
-    readonly GTIN8: 8;
-    /**
-     * GTIN-14.
-     */
-    readonly GTIN14: 14;
-};
-/**
- * GTIN type.
- */
-type GTINType = typeof GTINTypes[keyof typeof GTINTypes];
 /**
  * Levels at which GTIN is to be validated.
  */
@@ -597,10 +881,14 @@ declare const GTINLevels: {
      */
     readonly OtherThanRetailConsumer: 2;
 };
+/**
+ * GTIN level key.
+ */
+type GTINLevelKey = keyof typeof GTINLevels;
 /**
  * GTIN level.
  */
-type GTINLevel = typeof GTINLevels[keyof typeof GTINLevels];
+type GTINLevel = typeof GTINLevels[GTINLevelKey];
 /**
  * Restricted Circulation Number reference.
  */
@@ -617,7 +905,7 @@ interface RCNReference {
 /**
  * GTIN validator.
  */
-declare class GTINValidator extends AbstractNumericIdentifierValidator {
+declare class GTINValidator extends AbstractNumericIdentifierValidator<GTINDescriptor> {
     /**
      * Validation parameters for optional indicator digit.
      */
@@ -626,13 +914,21 @@ declare class GTINValidator extends AbstractNumericIdentifierValidator {
      * Validation parameters for zero-suppressed GTIN-12.
      */
     private static readonly ZERO_SUPPRESSED_GTIN12_VALIDATION;
+    /**
+     * Prefix type.
+     */
+    private readonly _prefixType;
     /**
      * Constructor.
      *
-     * @param gtinType
-     * GTIN type.
+     * @param gtinBaseType
+     * GTIN base type (all except GTIN-14).
      */
-    constructor(gtinType: GTINType);
+    constructor(gtinBaseType: GTINBaseType);
+    /**
+     * @inheritDoc
+     */
+    get prefixType(): PrefixType;
     /**
      * @inheritDoc
      */
@@ -738,71 +1034,25 @@ declare class GTINValidator extends AbstractNumericIdentifierValidator {
      */
     static parseVariableMeasureRCN(format: string, rcn: string): RCNReference;
 }
-/**
- * GTIN-13 validator.
- */
-declare const GTIN13_VALIDATOR: GTINValidator;
-/**
- * GTIN-12 validator.
- */
-declare const GTIN12_VALIDATOR: GTINValidator;
-/**
- * GTIN-8 validator.
- */
-declare const GTIN8_VALIDATOR: GTINValidator;
-/**
- * GTIN validators indexed by prefix type.
- */
-declare const GTIN_VALIDATORS: Record<PrefixType, GTINValidator>;
 
-/**
- * Non-GTIN numeric identifier type.
- */
-type NonGTINNumericIdentifierType = Exclude<NumericIdentifierType, typeof IdentifierTypes.GTIN>;
 /**
  * Non-GTIN numeric identifier validator.
  */
-declare class NonGTINNumericIdentifierValidator extends AbstractNumericIdentifierValidator {
+declare class NonGTINNumericIdentifierValidator extends AbstractNumericIdentifierValidator<NonGTINNumericIdentifierDescriptor> {
     /**
      * Constructor.
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param leaderType
-     * Leader type.
      */
-    constructor(identifierType: IdentifierType, length: number, leaderType?: LeaderType);
+    constructor(identifierType: Exclude<NonGTINNumericIdentifierType, SerializableNumericIdentifierType>);
 }
-/**
- * GLN validator.
- */
-declare const GLN_VALIDATOR: NonGTINNumericIdentifierValidator;
-/**
- * SSCC validator.
- */
-declare const SSCC_VALIDATOR: NonGTINNumericIdentifierValidator;
-/**
- * GSRN validator.
- */
-declare const GSRN_VALIDATOR: NonGTINNumericIdentifierValidator;
-/**
- * GSIN validator.
- */
-declare const GSIN_VALIDATOR: NonGTINNumericIdentifierValidator;
 
 /**
- * Serializable numeric identifier type.
- */
-type SerializableNumericIdentifierType = Exclude<NonGTINNumericIdentifierType, typeof IdentifierTypes.GLN | typeof IdentifierTypes.SSCC | typeof IdentifierTypes.GSRN | typeof IdentifierTypes.GSIN>;
-/**
- * Serializable numeric identifier validator. Validates both serialized and non-serialized forms of
- * numeric identifiers that support serialization.
+ * Serializable numeric identifier validator. Validates both serialized and non-serialized forms of numeric identifiers
+ * that support serialization.
  */
-declare class SerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator {
+declare class SerializableNumericIdentifierValidator extends AbstractNumericIdentifierValidator<SerializableNumericIdentifierDescriptor> {
     /**
      * Serial component length.
      */
@@ -824,17 +1074,8 @@ declare class SerializableNumericIdentifierValidator extends NonGTINNumericIdent
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param serialComponentLength
-     * Serial component length.
-     *
-     * @param serialComponentCharacterSet
-     * Serial component character set.
      */
-    constructor(identifierType: IdentifierType, length: number, serialComponentLength: number, serialComponentCharacterSet: ContentCharacterSet);
+    constructor(identifierType: SerializableNumericIdentifierType);
     /**
      * Get the serial component length.
      */
@@ -856,37 +1097,20 @@ declare class SerializableNumericIdentifierValidator extends NonGTINNumericIdent
      */
     validate(identifier: string, validation?: IdentifierValidation): void;
 }
-/**
- * GRAI validator.
- */
-declare const GRAI_VALIDATOR: SerializableNumericIdentifierValidator;
-/**
- * GDTI validator.
- */
-declare const GDTI_VALIDATOR: SerializableNumericIdentifierValidator;
-/**
- * GCN validator.
- */
-declare const GCN_VALIDATOR: SerializableNumericIdentifierValidator;
 
-/**
- * Non-numeric identifier type.
- */
-type NonNumericIdentifierType = Exclude<IdentifierType, NumericIdentifierType>;
 /**
  * Non-numeric identifier validation parameters.
  */
 interface NonNumericIdentifierValidation extends IdentifierValidation {
     /**
-     * Exclusion support for reference. Prevents non-numeric identifier from being mistaken for numeric
-     * identifier.
+     * Exclusion support for reference. Prevents non-numeric identifier from being mistaken for numeric identifier.
      */
     exclusion?: typeof Exclusions.None | typeof Exclusions.AllNumeric | undefined;
 }
 /**
  * Non-numeric identifier validator.
  */
-declare class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierValidation> {
+declare class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierDescriptor, NonNumericIdentifierValidation> {
     /**
      * Validator to ensure that an identifier (minus check character pair) is not all numeric.
      */
@@ -900,17 +1124,8 @@ declare class NonNumericIdentifierValidator extends AbstractIdentifierValidator<
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param referenceCharacterSet
-     * Reference character set.
-     *
-     * @param requiresCheckCharacterPair
-     * True if the identifier requires a check character pair.
      */
-    constructor(identifierType: IdentifierType, length: number, referenceCharacterSet: ContentCharacterSet, requiresCheckCharacterPair?: boolean);
+    constructor(identifierType: NonNumericIdentifierType);
     /**
      * Determine if the identifier requires a check character pair.
      */
@@ -926,56 +1141,105 @@ declare class NonNumericIdentifierValidator extends AbstractIdentifierValidator<
      */
     validate(identifier: string, validation?: NonNumericIdentifierValidation): void;
 }
+
 /**
- * GIAI validator.
+ * Identifier validator type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
  */
-declare const GIAI_VALIDATOR: NonNumericIdentifierValidator;
+type IdentifierTypeValidator<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ? NonNumericIdentifierValidator : TIdentifierType extends SerializableNumericIdentifierType ? SerializableNumericIdentifierValidator : TIdentifierType extends NonGTINNumericIdentifierType ? NonGTINNumericIdentifierValidator : TIdentifierType extends typeof IdentifierTypes.GTIN ? GTINValidator : IdentifierValidator;
 /**
- * GINC validator.
+ * Identifier validators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
  */
-declare const GINC_VALIDATOR: NonNumericIdentifierValidator;
+type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ? Readonly<Record<GTINBaseType, GTINValidator>> : IdentifierTypeValidator<TIdentifierType>;
 /**
- * CPID validator.
+ * Identifier validators record type.
  */
-declare const CPID_VALIDATOR: NonNumericIdentifierValidator;
+type IdentifierValidatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
+};
 /**
- * GMN validator.
+ * Identifier validators for all identifier types.
  */
-declare const GMN_VALIDATOR: NonNumericIdentifierValidator;
-
+declare const IdentifierValidators: IdentifierValidatorsRecord;
 /**
- * Prefix provider.
+ * Determine if identifier validators or validator is GTIN validators.
+ *
+ * @param identifierValidatorsOrValidator
+ * Identifier validators or validator.
+ *
+ * @returns
+ * True if GTIN validators.
  */
-interface PrefixProvider {
-    /**
-     * Prefix type.
-     */
-    readonly prefixType: PrefixType;
-    /**
-     * Prefix appropriate to the prefix type.
-     */
-    readonly prefix: string;
-    /**
-     * Prefix as GS1 Company Prefix.
-     */
-    readonly gs1CompanyPrefix: string;
-    /**
-     * Prefix as U.P.C. Company Prefix if prefix type is {@link PrefixTypes.UPCCompanyPrefix} or undefined if not.
-     */
-    readonly upcCompanyPrefix: string | undefined;
-    /**
-     * Prefix as GS1-8 Prefix if prefix type is {@link PrefixTypes.GS18Prefix} or undefined if not.
-     */
-    readonly gs18Prefix: string | undefined;
-}
+declare function isGTINValidators(identifierValidatorsOrValidator: IdentifierValidatorsEntry<IdentifierType>): identifierValidatorsOrValidator is Readonly<Record<GTINBaseType, GTINValidator>>;
+/**
+ * Determine if identifier validator is a numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a numeric identifier validator.
+ */
+declare function isNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a GTIN validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a GTIN validator.
+ */
+declare function isGTINValidator(identifierValidator: IdentifierValidator): identifierValidator is GTINValidator;
+/**
+ * Determine if identifier validator is a non-GTIN numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-GTIN numeric identifier validator.
+ */
+declare function isNonGTINNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonGTINNumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a serializable numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a serializable numeric identifier validator.
+ */
+declare function isSerializableNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is SerializableNumericIdentifierValidator;
+/**
+ * Determine if identifier validator is a non-numeric identifier validator.
+ *
+ * @param identifierValidator
+ * Identifier validator.
+ *
+ * @returns
+ * True if identifier validator is a non-numeric identifier validator.
+ */
+declare function isNonNumericIdentifierValidator(identifierValidator: IdentifierValidator): identifierValidator is NonNumericIdentifierValidator;
 
 /**
  * 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 provider to which the identifier creator is bound.
  *
- * Keys are created based on a prefix defined in a prefix manager to which the identifier creator is bound.
+ * @template TIdentifierDescriptor
+ * Identifier descriptor type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
  */
-interface IdentifierCreator extends IdentifierValidator {
+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.
      */
@@ -990,11 +1254,67 @@ interface IdentifierCreator extends IdentifierValidator {
      */
     get referenceLength(): number;
 }
+
+/**
+ * Numeric identifier creator. Creates one or many numeric identifiers.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
+ */
+interface NumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends NumericIdentifierValidator<TNumericIdentifierDescriptor>, IdentifierCreator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
+    /**
+     * Get the capacity (`10**referenceLength`).
+     */
+    get capacity(): number;
+    /**
+     * Get the tweak for sparse creation.
+     */
+    get tweak(): bigint;
+    /**
+     * Set the tweak for sparse creation.
+     */
+    set tweak(value: bigint);
+    /**
+     * Create identifier(s) with reference(s) based on numeric value(s). The value(s) is/are converted to references of
+     * the appropriate length using the numeric creator.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param valueOrValues
+     * Numeric value(s).
+     *
+     * @param sparse
+     * If true, the value(s) are mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Identifier(s).
+     */
+    create: <TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse?: boolean) => TransformerOutput<TTransformerInput, string>;
+    /**
+     * Create all identifiers for the prefix from `0` to `capacity - 1`.
+     *
+     * The implementation creates the strings only as needed using an internal generator function. Although the result
+     * is equivalent to calling `creator.create(new Sequence(0, creator.capacity))`, this method is significantly
+     * faster.
+     *
+     * @returns
+     * All identifiers for the prefix.
+     */
+    createAll: () => Iterable<string>;
+}
+
 /**
- * Abstract identifier creator. Implements common functionality for an identifier creator, bound to a
- * {@link PrefixProvider}.
+ * Abstract identifier creator. Implements common functionality for an identifier creator, bound to a {@link
+ * PrefixProvider | prefix provider}.
+ *
+ * @template TIdentifierDescriptor
+ * Identifier descriptor type.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
  */
-declare abstract class AbstractIdentifierCreator implements IdentifierCreator {
+declare abstract class AbstractIdentifierCreator<TIdentifierDescriptor extends IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation> implements IdentifierCreator<TIdentifierDescriptor, TIdentifierValidation> {
     /**
      * Prefix provider.
      */
@@ -1004,80 +1324,63 @@ declare abstract class AbstractIdentifierCreator implements IdentifierCreator {
      */
     private _referenceLength;
     /**
-     * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
+     * Initialize the prefix provider. 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.
+     * Prefix within prefix provider 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;
-    abstract get identifierType(): IdentifierType;
-    abstract get prefixType(): PrefixType;
+    /**
+     * @inheritDoc
+     */
+    abstract get identifierType(): TIdentifierDescriptor["identifierType"];
+    /**
+     * @inheritDoc
+     */
+    abstract get prefixType(): TIdentifierDescriptor["prefixType"];
+    /**
+     * @inheritDoc
+     */
     abstract get length(): number;
-    abstract get referenceCharacterSet(): ContentCharacterSet;
-    abstract get referenceCreator(): CharacterSetCreator;
     /**
      * @inheritDoc
      */
-    get prefixProvider(): PrefixProvider;
+    abstract get referenceCharacterSet(): TIdentifierDescriptor["referenceCharacterSet"];
     /**
      * @inheritDoc
      */
-    get prefix(): string;
+    abstract get referenceCreator(): CharacterSetCreator;
     /**
      * @inheritDoc
      */
-    get referenceLength(): number;
-    abstract validate(identifier: string, validation?: IdentifierValidation): void;
-}
-
-/**
- * Numeric identifier creator. Creates one or many numeric identifiers.
- */
-interface NumericIdentifierCreator extends NumericIdentifierValidator, IdentifierCreator {
+    get prefixProvider(): PrefixProvider;
     /**
-     * Get the capacity (`10**referenceLength`).
+     * @inheritDoc
      */
-    get capacity(): number;
+    get prefix(): string;
     /**
-     * Create identifier(s) with reference(s) based on numeric value(s). The value(s) is/are converted to
-     * references of the appropriate length using {@linkcode NUMERIC_CREATOR}.
-     *
-     * @template TTransformerInput
-     * Transformer input type.
-     *
-     * @param valueOrValues
-     * Numeric value(s).
-     *
-     * @param sparse
-     * If true, the value(s) are mapped to a sparse sequence resistant to discovery. Default is false.
-     *
-     * @returns
-     * Identifier(s).
+     * @inheritDoc
      */
-    create: <TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse?: boolean) => TransformerOutput<TTransformerInput, string>;
+    get referenceLength(): number;
     /**
-     * Create all identifiers for the prefix from `0` to `capacity - 1`.
-     *
-     * The implementation creates the strings only as needed using an internal generator function. Although the result
-     * is equivalent to calling `creator.create(new Sequence(0, creator.capacity))`, this method is significantly
-     * faster.
-     *
-     * @returns
-     * All identifiers for the prefix.
+     * @inheritDoc
      */
-    createAll: () => Iterable<string>;
+    abstract validate(identifier: string, validation?: TIdentifierValidation): void;
 }
+
 /**
- * Abstract numeric identifier creator. Implements common functionality for a numeric identifier
- * creator.
+ * Abstract numeric identifier creator. Implements common functionality for a numeric identifier creator.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
  */
-declare abstract class AbstractNumericIdentifierCreator extends AbstractIdentifierCreator implements NumericIdentifierCreator {
+declare abstract class AbstractNumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor> extends AbstractIdentifierCreator<TNumericIdentifierDescriptor, NumericIdentifierValidation> implements NumericIdentifierCreator<TNumericIdentifierDescriptor> {
     /**
      * Capacity.
      */
@@ -1096,17 +1399,20 @@ declare abstract class AbstractNumericIdentifierCreator extends AbstractIdentifi
      * Prefix within prefix manager to use to calculate reference length.
      */
     protected init(prefixProvider: PrefixProvider, prefix: string): void;
+    /**
+     * Get the leader type.
+     */
     abstract get leaderType(): LeaderType;
     /**
      * @inheritDoc
      */
     get capacity(): number;
     /**
-     * Get the tweak for sparse creation.
+     * @inheritDoc
      */
     get tweak(): bigint;
     /**
-     * Set the tweak for sparse creation.
+     * @inheritDoc
      */
     set tweak(value: bigint);
     /**
@@ -1134,8 +1440,8 @@ declare abstract class AbstractNumericIdentifierCreator extends AbstractIdentifi
      * Remaining reference length. Initial value is `this.referenceLength`.
      *
      * @param extensionWeight
-     * If this value is not zero, the identifier has an extension digit, this call is setting it, and this value
-     * is applied to the calculation of the check digit.
+     * If this value is not zero, the identifier has an extension digit, this call is setting it, and this value is
+     * applied to the calculation of the check digit.
      *
      * @param weight
      * If the extension weight is zero, this value is applied to the calculation of the check digit.
@@ -1153,7 +1459,7 @@ declare abstract class AbstractNumericIdentifierCreator extends AbstractIdentifi
     createAll(): Iterable<string>;
 }
 
-declare const GTINCreator_base: ts_mixer_dist_types_types.Class<any[], GTINValidator & AbstractNumericIdentifierCreator, typeof GTINValidator & typeof AbstractNumericIdentifierCreator>;
+declare const GTINCreator_base: ts_mixer_dist_types_types.Class<any[], GTINValidator & AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>, typeof GTINValidator & (abstract new () => AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>)>;
 /**
  * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; no applicable to GTIN-14 type.
  */
@@ -1169,10 +1475,10 @@ declare class GTINCreator extends GTINCreator_base {
      * @param prefixProvider
      * Prefix provider.
      *
-     * @param gtinType
-     * GTIN type.
+     * @param gtinBaseType
+     * GTIN base type (all except GTIN-14).
      */
-    constructor(prefixProvider: PrefixProvider, gtinType: GTINType);
+    constructor(prefixProvider: PrefixProvider, gtinBaseType: GTINBaseType);
     /**
      * @inheritDoc
      */
@@ -1216,7 +1522,7 @@ declare class GTINCreator extends GTINCreator_base {
     static createVariableMeasureRCN(format: string, itemReference: number, priceOrWeight: number): string;
 }
 
-declare const NonGTINNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], NonGTINNumericIdentifierValidator & AbstractNumericIdentifierCreator, typeof NonGTINNumericIdentifierValidator & typeof AbstractNumericIdentifierCreator>;
+declare const NonGTINNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], NonGTINNumericIdentifierValidator & AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>, typeof NonGTINNumericIdentifierValidator & (abstract new () => AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>)>;
 /**
  * Non-GTIN numeric identifier creator.
  */
@@ -1230,17 +1536,11 @@ declare class NonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCr
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param leaderType
-     * Leader type.
      */
-    constructor(prefixProvider: PrefixProvider, identifierType: IdentifierType, length: number, leaderType?: LeaderType);
+    constructor(prefixProvider: PrefixProvider, identifierType: Exclude<NonGTINNumericIdentifierType, SerializableNumericIdentifierType>);
 }
 
-declare const SerializableNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], SerializableNumericIdentifierValidator & AbstractNumericIdentifierCreator, typeof SerializableNumericIdentifierValidator & typeof AbstractNumericIdentifierCreator>;
+declare const SerializableNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], SerializableNumericIdentifierValidator & AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>, typeof SerializableNumericIdentifierValidator & (abstract new () => AbstractNumericIdentifierCreator<NumericIdentifierDescriptor>)>;
 /**
  * Serializable numeric identifier creator.
  */
@@ -1254,17 +1554,8 @@ declare class SerializableNumericIdentifierCreator extends SerializableNumericId
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param serialComponentLength
-     * Serial component length.
-     *
-     * @param serialComponentCharacterSet
-     * Serial component character set.
      */
-    constructor(prefixProvider: PrefixProvider, identifierType: IdentifierType, length: number, serialComponentLength: number, serialComponentCharacterSet: ContentCharacterSet);
+    constructor(prefixProvider: PrefixProvider, identifierType: SerializableNumericIdentifierType);
     /**
      * Concatenate a validated base identifier with serial component(s).
      *
@@ -1319,7 +1610,7 @@ declare class SerializableNumericIdentifierCreator extends SerializableNumericId
     concatenate<TTransformerInput extends TransformerInput<string>>(baseIdentifier: string, serialComponentOrComponents: TTransformerInput): TransformerOutput<TTransformerInput, string>;
 }
 
-declare const NonNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], NonNumericIdentifierValidator & AbstractIdentifierCreator, typeof NonNumericIdentifierValidator & typeof AbstractIdentifierCreator>;
+declare const NonNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], NonNumericIdentifierValidator & AbstractIdentifierCreator<IdentifierDescriptor, IdentifierValidation>, typeof NonNumericIdentifierValidator & (abstract new () => AbstractIdentifierCreator<IdentifierDescriptor, IdentifierValidation>)>;
 /**
  * Non-numeric identifier creator.
  */
@@ -1337,17 +1628,8 @@ declare class NonNumericIdentifierCreator extends NonNumericIdentifierCreator_ba
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param referenceCharacterSet
-     * Reference character set.
-     *
-     * @param requiresCheckCharacterPair
-     * True if the identifier requires a check character pair.
      */
-    constructor(prefixProvider: PrefixProvider, identifierType: IdentifierType, length: number, referenceCharacterSet: ContentCharacterSet, requiresCheckCharacterPair?: boolean);
+    constructor(prefixProvider: PrefixProvider, identifierType: NonNumericIdentifierType);
     /**
      * Get the reference validation parameters.
      */
@@ -1367,26 +1649,96 @@ declare class NonNumericIdentifierCreator extends NonNumericIdentifierCreator_ba
     create<TTransformerInput extends TransformerInput<string>>(referenceOrReferences: TTransformerInput): TransformerOutput<TTransformerInput, string>;
 }
 
+/**
+ * Determine the identifier creator type for an identifier type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+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.
+ */
+type IdentifierCreatorsEntry<TIdentifierType extends IdentifierType> = IdentifierTypeCreator<TIdentifierType>;
+/**
+ * Identifier creators record type.
+ */
+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.
+ */
+declare function isNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NumericIdentifierCreator;
+/**
+ * Determine if identifier creator is a GTIN creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a GTIN creator.
+ */
+declare function isGTINCreator(identifierCreator: IdentifierCreator): identifierCreator is GTINCreator;
+/**
+ * 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.
+ */
+declare function isNonGTINNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonGTINNumericIdentifierCreator;
+/**
+ * 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.
+ */
+declare function isSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is SerializableNumericIdentifierCreator;
+/**
+ * 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.
+ */
+declare function isNonNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonNumericIdentifierCreator;
+
 /**
  * Prefix manager. This is the core class for identifier creation.
  *
- * A prefix manager may be created for any {@link PrefixType | prefix type}. As most applications work with a limited
- * number of prefixes for creating identifiers, prefix managers are cached in memory and may be reused.
+ * A prefix manager may be constructed for any {@link PrefixType | prefix type}. Construction may be done directly or
+ * via the static {@linkcode PrefixManager.get | get()} method, which allows for caching and reuse. As most applications
+ * work with a limited number of prefixes for creating identifiers, caching and reuse may be a more efficient option.
  *
- * Prefix managers are keyed by GS1 Company Prefix, so the prefix type that is requested may not match the prefix type
- * of the returned prefix manager. For example, the prefix manager for GS1 Company Prefix 0614141 is identical to the
- * one for U.P.C. Company Prefix 614141, with the prefix type equal to {@link PrefixTypes.UPCCompanyPrefix} and the
- * prefix equal to "614141".
+ * The prefix type and prefix are normalized before the prefix manager is constructed, so they may not match the input
+ * values. For example, the GS1 Company Prefix 0614141 is equivalent to U.P.C. Company Prefix 614141; both result in a
+ * prefix manager with prefix type equal to {@linkcode PrefixTypes.UPCCompanyPrefix} and prefix equal to "614141".
  *
- * To support the creation of sparse identifiers, a prefix manager maintains a {@link tweakFactor | tweak
- * factor} which is used, along with a type-specific multiplier, as the tweak when creating numeric identifiers.
- * The default tweak factor is the numeric value of the GS1 Company Prefix representation of the prefix preceded by '1'
- * to ensure uniqueness (i.e., so that prefixes 0 N1 N2 N3... and N1 N2 N3... produce different tweak factors). This is
- * usually sufficient for obfuscation, but as the sparse creation algorithm is reversible and as the GS1 Company Prefix
- * is discoverable via {@link https://www.gs1.org/services/verified-by-gs1 | Verified by GS1}, a user-defined tweak
- * factor should be used if a higher degree of obfuscation is required. When using a tweak factor other than the
- * default, care should be taken to restore it when resuming the application. A tweak factor of 0 creates a straight
- * sequence.
+ * To support the creation of sparse identifiers, a prefix manager maintains a {@link tweakFactor | tweak factor} which
+ * is used, along with a type-specific multiplier, as the tweak when creating numeric identifiers. The default tweak
+ * factor is the numeric value of the GS1 Company Prefix representation of the prefix preceded by '1' to ensure
+ * uniqueness (i.e., so that prefixes 0 N1 N2 N3... and N1 N2 N3... produce different tweak factors). This is usually
+ * sufficient for obfuscation, but as the sparse creation algorithm is reversible and as the GS1 Company Prefix is
+ * discoverable via {@link https://www.gs1.org/services/verified-by-gs1 | Verified by GS1}, a user-defined tweak factor
+ * should be used if a higher degree of obfuscation is required. When using a tweak factor other than the default, care
+ * should be taken to restore it when resuming the application. A tweak factor of 0 creates a straight sequence.
  */
 declare class PrefixManager implements PrefixProvider {
     /**
@@ -1411,11 +1763,11 @@ declare class PrefixManager implements PrefixProvider {
      */
     private readonly _gs1CompanyPrefix;
     /**
-     * U.P.C. Company Prefix if prefix type is {@link PrefixTypes.UPCCompanyPrefix}.
+     * U.P.C. Company Prefix if prefix type is {@linkcode PrefixTypes.UPCCompanyPrefix}.
      */
     private readonly _upcCompanyPrefix;
     /**
-     * GS1-8 Prefix if prefix type is {@link PrefixTypes.GS18Prefix}.
+     * GS1-8 Prefix if prefix type is {@linkcode PrefixTypes.GS18Prefix}.
      */
     private readonly _gs18Prefix;
     /**
@@ -1433,10 +1785,13 @@ declare class PrefixManager implements PrefixProvider {
     /**
      * Constructor.
      *
-     * @param gs1CompanyPrefix
-     * GS1 Company Prefix.
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
      */
-    private constructor();
+    constructor(prefixType: PrefixType, prefix: string);
     /**
      * Get the prefix type.
      */
@@ -1450,17 +1805,17 @@ declare class PrefixManager implements PrefixProvider {
      */
     get gs1CompanyPrefix(): string;
     /**
-     * Get the U.P.C. Company Prefix if prefix type is {@link PrefixTypes.UPCCompanyPrefix} or undefined if not.
+     * Get the U.P.C. Company Prefix if prefix type is {@linkcode PrefixTypes.UPCCompanyPrefix} or undefined if not.
      */
     get upcCompanyPrefix(): string | undefined;
     /**
-     * Get the GS1-8 Prefix if prefix type is {@link PrefixTypes.GS18Prefix} or undefined if not.
+     * Get the GS1-8 Prefix if prefix type is {@linkcode PrefixTypes.GS18Prefix} or undefined if not.
      */
     get gs18Prefix(): string | undefined;
     /**
      * Set the tweak for an identifier creator if it's a numeric identifier creator.
      *
-     * @param creator
+     * @param identifierCreator
      * Identifier creator.
      */
     private setCreatorTweak;
@@ -1495,10 +1850,16 @@ declare class PrefixManager implements PrefixProvider {
     /**
      * Get an identifier creator.
      *
+     * @template TIdentifierType
+     * Identifier type type.
+     *
      * @param identifierType
-     * Identifier type.
+     * Identifier type used to construct identifier creator.
      *
-     * @param constructorCallback
+     * @param constructorParameter
+     * Second constructor parameter passed to constructor callback alongside this.
+     *
+     * @param ConstructorCallback
      * Constructor callback.
      *
      * @returns
@@ -1508,8 +1869,8 @@ declare class PrefixManager implements PrefixProvider {
     /**
      * Get non-GTIN numeric identifier creator.
      *
-     * @param validator
-     * Validator on which identifier creator is based.
+     * @param identifierType
+     * Identifier type used to construct identifier creator.
      *
      * @returns
      * Identifier creator.
@@ -1518,8 +1879,8 @@ declare class PrefixManager implements PrefixProvider {
     /**
      * Get serialized numeric identifier creator.
      *
-     * @param validator
-     * Validator on which identifier creator is based.
+     * @param identifierType
+     * Identifier type used to construct identifier creator.
      *
      * @returns
      * Identifier creator.
@@ -1528,8 +1889,8 @@ declare class PrefixManager implements PrefixProvider {
     /**
      * Get non-numeric identifier creator.
      *
-     * @param validator
-     * Validator on which identifier creator is based.
+     * @param identifierType
+     * Identifier type used to construct identifier creator.
      *
      * @returns
      * Identifier creator.
@@ -1585,4 +1946,4 @@ declare class PrefixManager implements PrefixProvider {
     get gmnCreator(): NonNumericIdentifierCreator;
 }
 
-export { AI39_CREATOR, AI39_VALIDATOR, AI64_VALIDATOR, AI82_CREATOR, AI82_VALIDATOR, AbstractIdentifierCreator, AbstractIdentifierValidator, AbstractNumericIdentifierCreator, AbstractNumericIdentifierValidator, CPID_VALIDATOR, type ContentCharacterSet, ContentCharacterSets, GCN_VALIDATOR, GDTI_VALIDATOR, GIAI_VALIDATOR, GINC_VALIDATOR, GLN_VALIDATOR, GMN_VALIDATOR, GRAI_VALIDATOR, type GS1LocaleResources, GSIN_VALIDATOR, GSRN_VALIDATOR, GTIN12_VALIDATOR, GTIN13_VALIDATOR, GTIN8_VALIDATOR, GTINCreator, type GTINLevel, GTINLevels, type GTINType, GTINTypes, GTINValidator, GTIN_VALIDATORS, type IdentifierCreator, type IdentifierType, IdentifierTypes, type IdentifierValidation, type IdentifierValidator, type LeaderType, LeaderTypes, NonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierType, NonGTINNumericIdentifierValidator, NonNumericIdentifierCreator, type NonNumericIdentifierType, type NonNumericIdentifierValidation, NonNumericIdentifierValidator, type NumericIdentifierCreator, type NumericIdentifierType, type NumericIdentifierValidator, PrefixManager, type PrefixType, PrefixTypes, type PrefixValidation, PrefixValidator, type RCNReference, SSCC_VALIDATOR, SerializableNumericIdentifierCreator, type SerializableNumericIdentifierType, SerializableNumericIdentifierValidator, checkCharacterPair, checkDigit, checkDigitSum, gs1NS, gs1Resources, hasValidCheckCharacterPair, hasValidCheckDigit, i18nGS1Init, i18nextGS1, isValidPriceOrWeightCheckDigit, priceOrWeightCheckDigit };
+export { AI39_CREATOR, AI39_VALIDATOR, AI64_VALIDATOR, AI82_CREATOR, AI82_VALIDATOR, type ContentCharacterSet, type ContentCharacterSetKey, ContentCharacterSets, type GS1LocaleResources, type GTINBaseType, GTINCreator, type GTINDescriptor, type GTINLevel, GTINLevels, type GTINType, type GTINTypeKey, GTINTypes, GTINValidator, GTIN_BASE_TYPES, type IdentifierCreator, type IdentifierCreatorsEntry, type IdentifierCreatorsRecord, type IdentifierDescriptor, IdentifierDescriptors, type IdentifierDescriptorsEntry, type IdentifierDescriptorsRecord, type IdentifierType, type IdentifierTypeCreator, type IdentifierTypeDescriptor, type IdentifierTypeKey, type IdentifierTypeValidator, IdentifierTypes, type IdentifierValidation, type IdentifierValidator, IdentifierValidators, type IdentifierValidatorsEntry, type IdentifierValidatorsRecord, type LeaderType, type LeaderTypeKey, LeaderTypes, NonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierDescriptor, type NonGTINNumericIdentifierType, NonGTINNumericIdentifierValidator, NonNumericIdentifierCreator, type NonNumericIdentifierDescriptor, type NonNumericIdentifierType, type NonNumericIdentifierValidation, NonNumericIdentifierValidator, type NumericIdentifierCreator, type NumericIdentifierDescriptor, type NumericIdentifierType, type NumericIdentifierValidation, type NumericIdentifierValidator, PrefixManager, type PrefixType, type PrefixTypeKey, PrefixTypes, type PrefixValidation, PrefixValidator, type RCNReference, SerializableNumericIdentifierCreator, type SerializableNumericIdentifierDescriptor, type SerializableNumericIdentifierType, SerializableNumericIdentifierValidator, checkCharacterPair, checkDigit, checkDigitSum, gs1NS, gs1Resources, hasValidCheckCharacterPair, hasValidCheckDigit, i18nGS1Init, i18nextGS1, isGTINCreator, isGTINDescriptor, isGTINDescriptors, isGTINValidator, isGTINValidators, isNonGTINNumericIdentifierCreator, isNonGTINNumericIdentifierDescriptor, isNonGTINNumericIdentifierValidator, isNonNumericIdentifierCreator, isNonNumericIdentifierDescriptor, isNonNumericIdentifierValidator, isNumericIdentifierCreator, isNumericIdentifierDescriptor, isNumericIdentifierValidator, isSerializableNumericIdentifierCreator, isSerializableNumericIdentifierDescriptor, isSerializableNumericIdentifierValidator, isValidPriceOrWeightCheckDigit, priceOrWeightCheckDigit };