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

package/dist/index.d.cts

@@ -0,0 +1,1588 @@
+import { I18nEnvironment } from '@aidc-toolkit/core';
+import { Resource, i18n } from 'i18next';
+import { CharacterSetCreator, CharacterSetValidator, CharacterSetValidation, StringValidation, StringValidator, Exclusions, TransformerInput, TransformerOutput } from '@aidc-toolkit/utility';
+import * as ts_mixer_dist_types_types from 'ts-mixer/dist/types/types';
+
+declare const _default: {
+    readonly Check: {
+        readonly lengthOfStringForPriceOrWeightMustBeExactly: "Length {{length, number}} of string for price or weight must be 4 or 5";
+        readonly priceOrWeightComponent: "price or weight";
+        readonly lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length, number}} of string for check character pair must be less than or equal to {{maximumLength, number}}";
+    };
+    readonly Identifier: {
+        readonly identifierTypeLength: "{{identifierType}} must be {{length, number}} digits long";
+        readonly invalidCheckDigit: "Invalid check digit";
+        readonly invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long";
+        readonly invalidGTIN14Length: "GTIN must be 14 digits long";
+        readonly invalidZeroSuppressedGTIN12: "Invalid zero-suppressed GTIN-12";
+        readonly invalidZeroSuppressibleGTIN12: "GTIN-12 not zero-suppressible";
+        readonly invalidZeroSuppressedGTIN12AsGTIN13: "Invalid zero-suppressed GTIN-12 as GTIN-13";
+        readonly invalidZeroSuppressedGTIN12AsGTIN14: "Invalid zero-suppressed GTIN-12 as GTIN-14";
+        readonly invalidGTIN13AtRetail: "GTIN-13 at retail consumer trade item level can't start with zero";
+        readonly invalidGTINAtRetail: "GTIN not supported at retail consumer trade item level";
+        readonly invalidGTINAtOtherThanRetail: "GTIN not supported at other than retail consumer trade item level";
+        readonly invalidRCNLength: "RCN length must match format length";
+        readonly invalidVariableMeasureRCNFormat: "Invalid variable measure RCN format";
+        readonly invalidVariableMeasureRCNPrefix: "Invalid variable measure RCN prefix";
+        readonly invalidVariableMeasurePriceOrWeight: "Invalid variable measure price or weight";
+        readonly indicatorDigit: "indicator digit";
+        readonly serialComponent: "serial component";
+        readonly reference: "reference";
+        readonly referenceCantBeAllNumeric: "Reference can't be all-numeric";
+        readonly invalidCheckCharacterPair: "Invalid check character pair";
+    };
+    readonly Prefix: {
+        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\"";
+        readonly upcCompanyPrefixCantStartWith0000: "U.P.C. Company Prefix can't start with \"0000\"";
+        readonly gs18PrefixCantStartWith0: "GS1-8 Prefix can't start with \"0\"";
+        readonly identifierTypeNotSupportedByGS18Prefix: "{{identifierType}} not supported by GS1-8 Prefix";
+    };
+};
+
+declare const gs1NS = "aidct_gs1";
+/**
+ * Locale strings type is extracted from the English locale strings object.
+ */
+type GS1LocaleResources = typeof _default;
+/**
+ * GS1 resources.
+ */
+declare const gs1Resources: Resource;
+declare const i18nextGS1: i18n;
+/**
+ * Initialize internationalization.
+ *
+ * @param environment
+ * Environment in which the application is running.
+ *
+ * @param debug
+ * Debug setting.
+ *
+ * @returns
+ * Void promise.
+ */
+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}.
+ */
+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}.
+ */
+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}.
+ */
+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}.
+ */
+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.
+ */
+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}.
+ *
+ * @param exchangeWeights
+ * If true, start the weights at 1 instead of 3 on the right.
+ *
+ * @param s
+ * Numeric string.
+ *
+ * @returns
+ * Accumulated sum of each digit multiplied by the weight at its position.
+ */
+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}.
+ *
+ * @param s
+ * Numeric string.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function checkDigit(s: string): string;
+/**
+ * Determine if a numeric string has a valid check digit.
+ *
+ * @param s
+ * Numeric string with check digit.
+ *
+ * @returns
+ * True if the check digit is valid.
+ */
+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}.
+ *
+ * @param s
+ * Numeric string exactly four or five characters long.
+ *
+ * @returns
+ * Check digit 0-9 as a string.
+ */
+declare function priceOrWeightCheckDigit(s: string): string;
+/**
+ * Determine if a price or weight check digit is valid for numeric string.
+ *
+ * @param s
+ * Numeric string exactly four or five characters long.
+ *
+ * @param checkDigit
+ * Price or weight check digit.
+ *
+ * @returns
+ * True if the check digit is valid.
+ */
+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}.
+ *
+ * @param s
+ * GS1 AI encodable character set 82 string.
+ *
+ * @returns
+ * Check character pair.
+ */
+declare function checkCharacterPair(s: string): string;
+/**
+ * Determine if a GS1 AI encodable character set 82 string has a valid check character pair.
+ *
+ * @param s
+ * GS1 AI encodable character set 82 string with check character pair.
+ *
+ * @returns
+ * True if the check character pair is valid.
+ */
+declare function hasValidCheckCharacterPair(s: string): boolean;
+
+/**
+ * Prefix types.
+ */
+declare const PrefixTypes: {
+    /**
+     * GS1 Company Prefix.
+     */
+    readonly GS1CompanyPrefix: "GS1 Company Prefix";
+    /**
+     * U.P.C. Company Prefix.
+     */
+    readonly UPCCompanyPrefix: "U.P.C. Company Prefix";
+    /**
+     * GS1-8 Prefix.
+     */
+    readonly GS18Prefix: "GS1-8 Prefix";
+};
+/**
+ * Prefix type.
+ */
+type PrefixType = typeof PrefixTypes[keyof typeof PrefixTypes];
+
+/**
+ * Prefix validation parameters.
+ */
+interface PrefixValidation extends CharacterSetValidation {
+    /**
+     * Minimum length.
+     */
+    minimumLength: number;
+    /**
+     * Maximum length.
+     */
+    maximumLength: number;
+    /**
+     * Callback to localized prefix type name.
+     */
+    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.
+ */
+declare const PrefixValidator: {
+    readonly GS1_COMPANY_PREFIX_MINIMUM_LENGTH: 4;
+    readonly GS1_COMPANY_PREFIX_MAXIMUM_LENGTH: 12;
+    readonly UPC_COMPANY_PREFIX_MINIMUM_LENGTH: 6;
+    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;
+};
+
+/**
+ * Identifier types.
+ */
+declare const IdentifierTypes: {
+    /**
+     * Global Trade Item Number.
+     */
+    readonly GTIN: "GTIN";
+    /**
+     * Global Location Number.
+     */
+    readonly GLN: "GLN";
+    /**
+     * Serial Shipping Container Code.
+     */
+    readonly SSCC: "SSCC";
+    /**
+     * Global Returnable Asset Identifier.
+     */
+    readonly GRAI: "GRAI";
+    /**
+     * Global Individual Asset Identifier.
+     */
+    readonly GIAI: "GIAI";
+    /**
+     * Global Service Relation Number.
+     */
+    readonly GSRN: "GSRN";
+    /**
+     * Global Document Type Identifier.
+     */
+    readonly GDTI: "GDTI";
+    /**
+     * Global Identification Number for Consignment.
+     */
+    readonly GINC: "GINC";
+    /**
+     * Global Shipment Identification Number.
+     */
+    readonly GSIN: "GSIN";
+    /**
+     * Global Coupon Number.
+     */
+    readonly GCN: "GCN";
+    /**
+     * Component/Part Identifier.
+     */
+    readonly CPID: "CPID";
+    /**
+     * Global Model Number.
+     */
+    readonly GMN: "GMN";
+};
+/**
+ * Identifier type.
+ */
+type IdentifierType = typeof IdentifierTypes[keyof typeof IdentifierTypes];
+
+/**
+ * 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.
+ */
+type ContentCharacterSet = typeof ContentCharacterSets[keyof typeof ContentCharacterSets];
+/**
+ * Identifier validation parameters.
+ */
+interface IdentifierValidation extends StringValidation {
+    /**
+     * 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.
+     */
+    positionOffset?: number | undefined;
+}
+/**
+ * Identifier validator. Validates an identifier against its definition in section 3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * @template TIdentifierValidation
+ * Identifier validation type.
+ */
+interface IdentifierValidator<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 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 prefixType(): PrefixType;
+    /**
+     * Get the length. For numeric identifier types, the length is fixed; for alphanumeric identifier types, the length
+     * is the maximum.
+     */
+    get length(): number;
+    /**
+     * Get the reference character set.
+     */
+    get referenceCharacterSet(): ContentCharacterSet;
+    /**
+     * Get the reference creator.
+     */
+    get referenceCreator(): CharacterSetCreator;
+    /**
+     * Validate an identifier and throw an error if validation fails.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Identifier validation parameters.
+     */
+    validate: (identifier: string, validation?: TIdentifierValidation) => void;
+}
+/**
+ * Abstract identifier validator. Implements common functionality for an identifier validator.
+ */
+declare abstract class AbstractIdentifierValidator<TIdentifierValidation extends IdentifierValidation = IdentifierValidation> implements IdentifierValidator<TIdentifierValidation> {
+    private static readonly CHARACTER_SET_CREATORS;
+    /**
+     * Identifier type.
+     */
+    private readonly _identifierType;
+    /**
+     * Prefix type.
+     */
+    private readonly _prefixType;
+    /**
+     * Length.
+     */
+    private readonly _length;
+    /**
+     * Reference character set.
+     */
+    private readonly _referenceCharacterSet;
+    /**
+     * Reference creator.
+     */
+    private readonly _referenceCreator;
+    /**
+     * Get the character set creator for a character set.
+     *
+     * @param characterSet
+     * Character set.
+     *
+     * @returns
+     * Character set creator.
+     */
+    protected static creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator;
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param referenceCharacterSet
+     * Reference character set.
+     */
+    protected constructor(identifierType: IdentifierType, prefixType: PrefixType, length: number, referenceCharacterSet: ContentCharacterSet);
+    /**
+     * @inheritDoc
+     */
+    get identifierType(): IdentifierType;
+    /**
+     * @inheritDoc
+     */
+    get prefixType(): PrefixType;
+    /**
+     * @inheritDoc
+     */
+    get length(): number;
+    /**
+     * @inheritDoc
+     */
+    get referenceCharacterSet(): ContentCharacterSet;
+    /**
+     * @inheritDoc
+     */
+    get referenceCreator(): CharacterSetCreator;
+    /**
+     * Pad an identifier on the left with zero-value character for validation purposes. This is done to align an
+     * identifier with a position offset for any error message that may be thrown by the reference validator.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Identifier validation parameters.
+     *
+     * @returns
+     * Padded identifier.
+     */
+    protected padIdentifier(identifier: string, validation: IdentifierValidation | undefined): string;
+    /**
+     * Validate the prefix within an identifier.
+     *
+     * @param partialIdentifier
+     * Partial identifier.
+     *
+     * @param positionOffset
+     * Position offset within a larger string.
+     */
+    protected validatePrefix(partialIdentifier: string, positionOffset?: number): void;
+    abstract validate(identifier: string, validation?: TIdentifierValidation): void;
+}
+
+/**
+ * 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.
+ */
+declare abstract class AbstractNumericIdentifierValidator extends AbstractIdentifierValidator implements NumericIdentifierValidator {
+    /**
+     * Leader type.
+     */
+    private readonly _leaderType;
+    /**
+     * Prefix position, determined by the leader type.
+     */
+    private readonly _prefixPosition;
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    protected constructor(identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType);
+    /**
+     * @inheritDoc
+     */
+    get leaderType(): LeaderType;
+    /**
+     * @inheritDoc
+     */
+    validate(identifier: string, validation?: IdentifierValidation): 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.
+ */
+declare const GTINLevels: {
+    /**
+     * Any level (level is ignored).
+     */
+    readonly Any: 0;
+    /**
+     * Retail consumer trade item level, supporting GTIN-13, GTIN-12 (optionally zero-suppressed), and GTIN-8.
+     */
+    readonly RetailConsumer: 1;
+    /**
+     * Other than retail consumer trade item level, supporting GTIN-13, GTIN-12 (not zero-suppressed), and GTIN-14.
+     */
+    readonly OtherThanRetailConsumer: 2;
+};
+/**
+ * GTIN level.
+ */
+type GTINLevel = typeof GTINLevels[keyof typeof GTINLevels];
+/**
+ * Restricted Circulation Number reference.
+ */
+interface RCNReference {
+    /**
+     * Item reference.
+     */
+    itemReference: number;
+    /**
+     * Price or weight (whole number only).
+     */
+    priceOrWeight: number;
+}
+/**
+ * GTIN validator.
+ */
+declare class GTINValidator extends AbstractNumericIdentifierValidator {
+    /**
+     * Validation parameters for optional indicator digit.
+     */
+    private static readonly OPTIONAL_INDICATOR_DIGIT_VALIDATION;
+    /**
+     * Validation parameters for zero-suppressed GTIN-12.
+     */
+    private static readonly ZERO_SUPPRESSED_GTIN12_VALIDATION;
+    /**
+     * Constructor.
+     *
+     * @param gtinType
+     * GTIN type.
+     */
+    constructor(gtinType: GTINType);
+    /**
+     * @inheritDoc
+     */
+    get gtinType(): GTINType;
+    /**
+     * @inheritDoc
+     */
+    protected validatePrefix(partialIdentifier: string, positionOffset?: number): void;
+    /**
+     * Zero suppress a GTIN-12.
+     *
+     * @param gtin12
+     * GTIN-12.
+     *
+     * @returns
+     * Zero-suppressed GTIN-12.
+     */
+    static zeroSuppress(gtin12: string): string;
+    /**
+     * Zero expand a zero-suppressed GTIN-12.
+     *
+     * @param zeroSuppressedGTIN12
+     * Zero-suppressed GTIN-12.
+     *
+     * @returns
+     * GTIN-12.
+     */
+    static zeroExpand(zeroSuppressedGTIN12: string): string;
+    /**
+     * Convert a GTIN of any length to a GTIN-14 with an optional indicator digit.
+     *
+     * @param indicatorDigit
+     * Indicator digit. If blank, assumes "0" if the GTIN is not already a GTIN-14.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @returns
+     * GTIN-14.
+     */
+    static convertToGTIN14(indicatorDigit: string, gtin: string): string;
+    /**
+     * Normalize a GTIN of any length.
+     * - A GTIN-14 that starts with six zeros or a GTIN-13 that starts with five zeros is normalized to GTIN-8.
+     * - A GTIN-14 that starts with two zeros or a GTIN-13 that starts with one zero is normalized to GTIN-12.
+     * - A GTIN-14 that starts with one zero is normalized to GTIN-13.
+     * - Otherwise, the GTIN is unchanged.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @returns
+     * Normalized GTIN.
+     */
+    static normalize(gtin: string): string;
+    /**
+     * Validate any GTIN, optionally against a level.
+     *
+     * @param gtin
+     * GTIN.
+     *
+     * @param gtinLevel
+     * Level at which GTIN is to be validated.
+     */
+    static validateAny(gtin: string, gtinLevel?: GTINLevel): void;
+    /**
+     * Validate a GTIN-14.
+     *
+     * @param gtin14
+     * GTIN-14.
+     */
+    static validateGTIN14(gtin14: string): void;
+    /**
+     * Parse a Restricted Circulation Number (RCN) using a variable measure trade item format. The format is a 12- or
+     * 13-character string (for RCN-12 or RCN-13 respectively), containing the following:
+     *
+     * - '2' - The first character of the RCN.
+     * - '0'-'9' - The second character of the RCN (RCN-13 only).
+     * - 'I' - One or more, in sequence, for the item reference.
+     * - 'P' - One or more, in sequence, for the price or weight.
+     * - 'V' - Zero or one, for the price or weight check digit.
+     * - 'C' - The check digit of the entire RCN.
+     *
+     * The 'I', 'P', and 'V' formats may be in any order.
+     *
+     * Some examples:
+     *
+     * - 2IIIIIVPPPPC - RCN-12 with a five-digit item reference, a price or weight check digit, and a four-digit price
+     * or weight.
+     * - 23IIIIVPPPPPC - RCN-13 with a four-digit item reference, a price or weight check digit, and a five-digit price
+     * or weight.
+     * - 2IIIIIIPPPPC - RCN-12 with a six-digit item reference and a four-digit price or eight.
+     * - 29IIIIIPPPPPC - RCN-13 with a five-digit item reference and a five-digit price or weight.
+     *
+     * @param format
+     * Format.
+     *
+     * @param rcn
+     * RCN.
+     *
+     * @returns
+     * RCN reference.
+     */
+    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 {
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    constructor(identifierType: IdentifierType, length: number, leaderType?: LeaderType);
+}
+/**
+ * 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.
+ */
+declare class SerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator {
+    /**
+     * Serial component length.
+     */
+    private readonly _serialComponentLength;
+    /**
+     * Serial component character set.
+     */
+    private readonly _serialComponentCharacterSet;
+    /**
+     * Serial component validation parameters.
+     */
+    private readonly _serialComponentValidation;
+    /**
+     * Serial component creator.
+     */
+    private readonly _serialComponentCreator;
+    /**
+     * Constructor.
+     *
+     * @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);
+    /**
+     * Get the serial component length.
+     */
+    get serialComponentLength(): number;
+    /**
+     * Get the serial component character set.
+     */
+    get serialComponentCharacterSet(): ContentCharacterSet;
+    /**
+     * Get the serial component validation parameters.
+     */
+    protected get serialComponentValidation(): CharacterSetValidation;
+    /**
+     * Get the serial component creator.
+     */
+    get serialComponentCreator(): CharacterSetCreator;
+    /**
+     * @inheritDoc
+     */
+    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?: typeof Exclusions.None | typeof Exclusions.AllNumeric | undefined;
+}
+/**
+ * Non-numeric identifier validator.
+ */
+declare class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierValidation> {
+    /**
+     * Validator to ensure that an identifier (minus check character pair) is not all numeric.
+     */
+    private static readonly NOT_ALL_NUMERIC_VALIDATOR;
+    /**
+     * True if the identifier requires a check character pair.
+     */
+    private readonly _requiresCheckCharacterPair;
+    /**
+     * Constructor.
+     *
+     * @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);
+    /**
+     * Determine if the identifier requires a check character pair.
+     */
+    get requiresCheckCharacterPair(): boolean;
+    /**
+     * Validate a non-numeric identifier and throw an error if validation fails.
+     *
+     * @param identifier
+     * Identifier.
+     *
+     * @param validation
+     * Validation parameters.
+     */
+    validate(identifier: string, validation?: NonNumericIdentifierValidation): void;
+}
+/**
+ * GIAI validator.
+ */
+declare const GIAI_VALIDATOR: NonNumericIdentifierValidator;
+/**
+ * GINC validator.
+ */
+declare const GINC_VALIDATOR: NonNumericIdentifierValidator;
+/**
+ * CPID validator.
+ */
+declare const CPID_VALIDATOR: NonNumericIdentifierValidator;
+/**
+ * GMN validator.
+ */
+declare const GMN_VALIDATOR: NonNumericIdentifierValidator;
+
+/**
+ * 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 {@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;
+}
+
+/**
+ * Identifier creator. Creates an identifier based on its definition in section 3 of the {@link
+ * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * Keys are created based on a prefix defined in a prefix manager to which the identifier creator is bound.
+ */
+interface IdentifierCreator extends IdentifierValidator {
+    /**
+     * Get the prefix provider to which this identifier creator is bound.
+     */
+    get prefixProvider(): PrefixProvider;
+    /**
+     * Get the prefix, equivalent to calling {@linkcode PrefixProvider.prefix | prefixProvider.prefix} for a GTIN or
+     * {@linkcode PrefixProvider.gs1CompanyPrefix | prefixProvider.gs1CompanyPrefix} for all other identifier types.
+     */
+    get prefix(): string;
+    /**
+     * Get the reference length.
+     */
+    get referenceLength(): number;
+}
+/**
+ * Abstract identifier creator. Implements common functionality for an identifier creator, bound to a
+ * {@link PrefixProvider}.
+ */
+declare abstract class AbstractIdentifierCreator implements IdentifierCreator {
+    /**
+     * Prefix provider.
+     */
+    private _prefixProvider;
+    /**
+     * Reference length.
+     */
+    private _referenceLength;
+    /**
+     * 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;
+    abstract get identifierType(): IdentifierType;
+    abstract get prefixType(): PrefixType;
+    abstract get length(): number;
+    abstract get referenceCharacterSet(): ContentCharacterSet;
+    abstract get referenceCreator(): CharacterSetCreator;
+    /**
+     * @inheritDoc
+     */
+    get prefixProvider(): PrefixProvider;
+    /**
+     * @inheritDoc
+     */
+    get prefix(): string;
+    /**
+     * @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 the capacity (`10**referenceLength`).
+     */
+    get capacity(): number;
+    /**
+     * 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).
+     */
+    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 numeric identifier creator. Implements common functionality for a numeric identifier
+ * creator.
+ */
+declare abstract class AbstractNumericIdentifierCreator extends AbstractIdentifierCreator implements NumericIdentifierCreator {
+    /**
+     * Capacity.
+     */
+    private _capacity;
+    /**
+     * Tweak for sparse creation.
+     */
+    private _tweak;
+    /**
+     * 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.
+     */
+    protected init(prefixProvider: PrefixProvider, prefix: string): void;
+    abstract get leaderType(): LeaderType;
+    /**
+     * @inheritDoc
+     */
+    get capacity(): number;
+    /**
+     * Get the tweak for sparse creation.
+     */
+    get tweak(): bigint;
+    /**
+     * Set the tweak for sparse creation.
+     */
+    set tweak(value: bigint);
+    /**
+     * Build an identifier from a reference by merging it with the prefix and adding the check digit.
+     *
+     * @param reference
+     * Identifier reference.
+     *
+     * @returns
+     * Identifier.
+     */
+    private buildIdentifier;
+    /**
+     * @inheritDoc
+     */
+    create<TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string>;
+    /**
+     * Create all identifiers from a partial identifier. Call is recursive until remaining reference
+     * length is 0.
+     *
+     * @param partialIdentifier
+     * Partial identifier. Initial value is `this.prefix`.
+     *
+     * @param remainingReferenceLength
+     * 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.
+     *
+     * @param weight
+     * If the extension weight is zero, this value is applied to the calculation of the check digit.
+     *
+     * @param partialCheckDigitSum
+     * Partial check digit sum for the partial identifier.
+     *
+     * @yields
+     * Identifier.
+     */
+    private static createAllPartial;
+    /**
+     * @inheritDoc
+     */
+    createAll(): Iterable<string>;
+}
+
+declare const GTINCreator_base: ts_mixer_dist_types_types.Class<any[], GTINValidator & AbstractNumericIdentifierCreator, typeof GTINValidator & typeof AbstractNumericIdentifierCreator>;
+/**
+ * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; no applicable to GTIN-14 type.
+ */
+declare class GTINCreator extends GTINCreator_base {
+    /**
+     * Validation parameters for required indicator digit.
+     */
+    private static readonly REQUIRED_INDICATOR_DIGIT_VALIDATION;
+    /**
+     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
+     * provider type.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @param gtinType
+     * GTIN type.
+     */
+    constructor(prefixProvider: PrefixProvider, gtinType: GTINType);
+    /**
+     * @inheritDoc
+     */
+    get prefix(): string;
+    /**
+     * Create GTIN-14(s) with an indicator digit and reference(s) based on numeric value(s). The value(s) is/are
+     * converted to reference(s) of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param indicatorDigit
+     * Indicator digit.
+     *
+     * @param valueOrValues
+     * Numeric value(s).
+     *
+     * @param sparse
+     * If true, the value(s) is/are mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * GTIN-14(s).
+     */
+    createGTIN14<TTransformerInput extends TransformerInput<number | bigint>>(indicatorDigit: string, valueOrValues: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string>;
+    /**
+     * Create a Restricted Circulation Number (RCN) using a variable measure trade item format. See {@linkcode
+     * GTINValidator.parseVariableMeasureRCN} for format details.
+     *
+     * @param format
+     * Format.
+     *
+     * @param itemReference
+     * Item reference.
+     *
+     * @param priceOrWeight
+     * Price or weight (whole number only).
+     *
+     * @returns
+     * RCN-12 or RCN-13.
+     */
+    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>;
+/**
+ * Non-GTIN numeric identifier creator.
+ */
+declare class NonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator_base {
+    /**
+     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
+     * provider type.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param length
+     * Length.
+     *
+     * @param leaderType
+     * Leader type.
+     */
+    constructor(prefixProvider: PrefixProvider, identifierType: IdentifierType, length: number, leaderType?: LeaderType);
+}
+
+declare const SerializableNumericIdentifierCreator_base: ts_mixer_dist_types_types.Class<any[], SerializableNumericIdentifierValidator & AbstractNumericIdentifierCreator, typeof SerializableNumericIdentifierValidator & typeof AbstractNumericIdentifierCreator>;
+/**
+ * Serializable numeric identifier creator.
+ */
+declare class SerializableNumericIdentifierCreator extends SerializableNumericIdentifierCreator_base {
+    /**
+     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
+     * provider type.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @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);
+    /**
+     * Concatenate a validated base identifier with serial component(s).
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param baseIdentifier
+     * Base identifier.
+     *
+     * @param serialComponentOrComponents
+     * Serial component(s).
+     *
+     * @returns
+     * Serialized identifier(s).
+     */
+    private concatenateValidated;
+    /**
+     * Create serialized identifier(s) with a reference based on a numeric value concatenated with serial component(s).
+     * The value is converted to a reference of the appropriate length using a numeric creator.
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param value
+     * Numeric value of the reference.
+     *
+     * @param serialComponentOrComponents
+     * Serial component(s).
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     *
+     * @returns
+     * Serialized identifiers.
+     */
+    createSerialized<TTransformerInput extends TransformerInput<string>>(value: number, serialComponentOrComponents: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string>;
+    /**
+     * Concatenate a base identifier with serial component(s).
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param baseIdentifier
+     * Base identifier.
+     *
+     * @param serialComponentOrComponents
+     * Serial component(s).
+     *
+     * @returns
+     * Serialized identifier(s).
+     */
+    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>;
+/**
+ * Non-numeric identifier creator.
+ */
+declare class NonNumericIdentifierCreator extends NonNumericIdentifierCreator_base {
+    /**
+     * Reference validation parameters.
+     */
+    private readonly _referenceValidation;
+    /**
+     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
+     * provider type.
+     *
+     * @param prefixProvider
+     * Prefix provider.
+     *
+     * @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);
+    /**
+     * Get the reference validation parameters.
+     */
+    protected get referenceValidation(): CharacterSetValidation;
+    /**
+     * Create identifier(s) with reference(s).
+     *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
+     * @param referenceOrReferences
+     * Reference(s).
+     *
+     * @returns
+     * Identifier(s).
+     */
+    create<TTransformerInput extends TransformerInput<string>>(referenceOrReferences: TTransformerInput): TransformerOutput<TTransformerInput, string>;
+}
+
+/**
+ * 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.
+ *
+ * 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".
+ *
+ * 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 {
+    /**
+     * Cached prefix managers, keyed by GS1 Company Prefix.
+     */
+    private static readonly PREFIX_MANAGERS_MAP;
+    /**
+     * Creator tweak factors. Different numeric identifier types have different tweak factors so that sparse creation
+     * generates different sequences for each.
+     */
+    private static readonly CREATOR_TWEAK_FACTORS;
+    /**
+     * Normalized prefix type.
+     */
+    private readonly _prefixType;
+    /**
+     * Normalized prefix.
+     */
+    private readonly _prefix;
+    /**
+     * Prefix as GS1 Company Prefix.
+     */
+    private readonly _gs1CompanyPrefix;
+    /**
+     * U.P.C. Company Prefix if prefix type is {@link PrefixTypes.UPCCompanyPrefix}.
+     */
+    private readonly _upcCompanyPrefix;
+    /**
+     * GS1-8 Prefix if prefix type is {@link PrefixTypes.GS18Prefix}.
+     */
+    private readonly _gs18Prefix;
+    /**
+     * Default tweak factor.
+     */
+    private readonly _defaultTweakFactor;
+    /**
+     * Tweak factor.
+     */
+    private _tweakFactor;
+    /**
+     * Cached identifier creators.
+     */
+    private readonly _identifierCreators;
+    /**
+     * Constructor.
+     *
+     * @param gs1CompanyPrefix
+     * GS1 Company Prefix.
+     */
+    private constructor();
+    /**
+     * Get the prefix type.
+     */
+    get prefixType(): PrefixType;
+    /**
+     * Get the prefix.
+     */
+    get prefix(): string;
+    /**
+     * Get the GS1 Company Prefix.
+     */
+    get gs1CompanyPrefix(): string;
+    /**
+     * Get the U.P.C. Company Prefix if prefix type is {@link 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 gs18Prefix(): string | undefined;
+    /**
+     * Set the tweak for an identifier creator if it's a numeric identifier creator.
+     *
+     * @param creator
+     * Identifier creator.
+     */
+    private setCreatorTweak;
+    /**
+     * Get the tweak factor.
+     */
+    get tweakFactor(): bigint;
+    /**
+     * Set the tweak factor.
+     *
+     * @param value
+     * Tweak factor.
+     */
+    set tweakFactor(value: number | bigint);
+    /**
+     * Reset the tweak factor to its default (numeric value of the GS1 Company Prefix preceded by '1').
+     */
+    resetTweakFactor(): void;
+    /**
+     * Get a prefix manager.
+     *
+     * @param prefixType
+     * Prefix type.
+     *
+     * @param prefix
+     * Prefix.
+     *
+     * @returns
+     * Prefix manager with normalized prefix type and prefix.
+     */
+    static get(prefixType: PrefixType, prefix: string): PrefixManager;
+    /**
+     * Get an identifier creator.
+     *
+     * @param identifierType
+     * Identifier type.
+     *
+     * @param constructorCallback
+     * Constructor callback.
+     *
+     * @returns
+     * Identifier creator.
+     */
+    private getIdentifierCreator;
+    /**
+     * Get non-GTIN numeric identifier creator.
+     *
+     * @param validator
+     * Validator on which identifier creator is based.
+     *
+     * @returns
+     * Identifier creator.
+     */
+    private getNonGTINNumericIdentifierCreator;
+    /**
+     * Get serialized numeric identifier creator.
+     *
+     * @param validator
+     * Validator on which identifier creator is based.
+     *
+     * @returns
+     * Identifier creator.
+     */
+    private getSerializableNumericIdentifierCreator;
+    /**
+     * Get non-numeric identifier creator.
+     *
+     * @param validator
+     * Validator on which identifier creator is based.
+     *
+     * @returns
+     * Identifier creator.
+     */
+    private getNonNumericIdentifierCreator;
+    /**
+     * Get GTIN creator.
+     */
+    get gtinCreator(): GTINCreator;
+    /**
+     * Get GLN creator.
+     */
+    get glnCreator(): NonGTINNumericIdentifierCreator;
+    /**
+     * Get SSCC creator.
+     */
+    get ssccCreator(): NonGTINNumericIdentifierCreator;
+    /**
+     * Get GRAI creator.
+     */
+    get graiCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get GIAI creator.
+     */
+    get giaiCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GSRN creator.
+     */
+    get gsrnCreator(): NonGTINNumericIdentifierCreator;
+    /**
+     * Get GDTI creator.
+     */
+    get gdtiCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get GINC creator.
+     */
+    get gincCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GSIN creator.
+     */
+    get gsinCreator(): NonGTINNumericIdentifierCreator;
+    /**
+     * Get GCN creator.
+     */
+    get gcnCreator(): SerializableNumericIdentifierCreator;
+    /**
+     * Get CPID creator.
+     */
+    get cpidCreator(): NonNumericIdentifierCreator;
+    /**
+     * Get GMN creator.
+     */
+    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 };