@aidc-toolkit/app-extension 1.0.26-beta → 1.0.28-beta

package/src/gs1/character-set-proxy.ts

@@ -1,14 +1,14 @@
 import { AI39_CREATOR, AI64_VALIDATOR, AI82_CREATOR } from "@aidc-toolkit/gs1";
 import type { AppExtension } from "../app-extension.js";
-import { expandParameterDescriptor, ProxyClass } from "../descriptor.js";
+import { expandParameterDescriptor, proxy } from "../proxy.js";
 import type { ErrorExtends } from "../type.js";
-import { CharacterSetCreatorProxy, CharacterSetValidatorProxy } from "../utility/index.js";
 import {
     exclusionAllNumericParameterDescriptor,
     exclusionNoneParameterDescriptor
 } from "../utility/character-set-descriptor.js";
+import { CharacterSetCreatorProxy, CharacterSetValidatorProxy } from "../utility/index.js";
 
-@ProxyClass({
+@proxy.describeClass(false, {
     namespace: "GS1",
     methodInfix: "AI82",
     replaceParameterDescriptors: [
@@ -24,7 +24,7 @@ export class AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<T
     }
 }
 
-@ProxyClass({
+@proxy.describeClass(false, {
     namespace: "GS1",
     methodInfix: "AI39",
     replaceParameterDescriptors: [
@@ -40,7 +40,7 @@ export class AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<T
     }
 }
 
-@ProxyClass({
+@proxy.describeClass(false, {
     namespace: "GS1",
     methodInfix: "AI64"
 })

package/src/gs1/check-proxy.ts

@@ -6,8 +6,9 @@ import {
     isValidPriceOrWeightCheckDigit,
     priceOrWeightCheckDigit
 } from "@aidc-toolkit/gs1";
-import { type ParameterDescriptor, ProxyClass, ProxyMethod, ProxyParameter, Types } from "../descriptor.js";
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
 import { LibProxy } from "../lib-proxy.js";
+import { proxy } from "../proxy.js";
 import type { ErrorExtends, Matrix, MatrixResultError, ResultError } from "../type.js";
 
 const checkSParameterDescriptor: ParameterDescriptor = {
@@ -17,106 +18,98 @@ const checkSParameterDescriptor: ParameterDescriptor = {
     isRequired: true
 };
 
-const numericSParameterDescriptor: ParameterDescriptor = {
+const numericSParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: checkSParameterDescriptor,
     name: "numericS"
 };
 
-const numericSFourOrFiveDigitsParameterDescriptor: ParameterDescriptor = {
+const numericSFourOrFiveDigitsParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: numericSParameterDescriptor,
     sortOrder: 0,
     name: "numericSFourOrFiveDigits"
 };
 
-const numericSWithCheckDigitParameterDescriptor: ParameterDescriptor = {
+const numericSWithCheckDigitParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: numericSParameterDescriptor,
     sortOrder: 1,
     name: "numericSWithCheckDigit"
 };
 
-const checkDigitParameterDescriptor: ParameterDescriptor = {
+const checkDigitParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: numericSParameterDescriptor,
     sortOrder: 2,
     name: "checkDigit",
     isMatrix: false
 };
 
-const ai82SParameterDescriptor: ParameterDescriptor = {
+const ai82SParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: checkSParameterDescriptor,
     name: "ai82S"
 };
 
-// eslint-disable-next-line no-useless-assignment -- ESLint bug.
-const ai82SWithCheckCharacterPairParameterDescriptor: ParameterDescriptor = {
+const ai82SWithCheckCharacterPairParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: ai82SParameterDescriptor,
     name: "ai82SWithCheckCharacterPair"
 };
 
-@ProxyClass({
+@proxy.describeClass(false, {
     namespace: "GS1"
 })
 export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true
+        isMatrix: true,
+        parameterDescriptors: [numericSParameterDescriptor]
     })
-    checkDigit(
-        @ProxyParameter(numericSParameterDescriptor) matrixSs: Matrix<string>
-    ): MatrixResultError<string, ThrowError, TError> {
+    checkDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
         return this.mapMatrix(matrixSs, s => checkDigit(s));
     }
 
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true
+        isMatrix: true,
+        parameterDescriptors: [numericSWithCheckDigitParameterDescriptor]
     })
-    hasValidCheckDigit(
-        @ProxyParameter(numericSWithCheckDigitParameterDescriptor) matrixSs: Matrix<string>
-    ): MatrixResultError<boolean, ThrowError, TError> {
+    hasValidCheckDigit(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError> {
         return this.mapMatrix(matrixSs, s => hasValidCheckDigit(s));
     }
 
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true
+        isMatrix: true,
+        parameterDescriptors: [numericSFourOrFiveDigitsParameterDescriptor]
     })
-    priceOrWeightCheckDigit(
-        @ProxyParameter(numericSFourOrFiveDigitsParameterDescriptor) matrixSs: Matrix<string>
-    ): MatrixResultError<string, ThrowError, TError> {
+    priceOrWeightCheckDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
         return this.mapMatrix(matrixSs, s => priceOrWeightCheckDigit(s));
     }
 
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: false
-    })
-    isValidPriceOrWeightCheckDigit(
-        @ProxyParameter({
+        isMatrix: false,
+        parameterDescriptors: [{
             ...numericSFourOrFiveDigitsParameterDescriptor,
             isMatrix: false
-        }) s: string,
-        @ProxyParameter(checkDigitParameterDescriptor) checkDigit: string
-    ): ResultError<boolean, ThrowError, TError> {
+        }, checkDigitParameterDescriptor]
+    })
+    isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): ResultError<boolean, ThrowError, TError> {
         return isValidPriceOrWeightCheckDigit(s, checkDigit);
     }
 
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true
+        isMatrix: true,
+        parameterDescriptors: [ai82SParameterDescriptor]
     })
-    checkCharacterPair(
-        @ProxyParameter(ai82SParameterDescriptor) matrixSs: Matrix<string>
-    ): MatrixResultError<string, ThrowError, TError> {
+    checkCharacterPair(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
         return this.mapMatrix(matrixSs, s => checkCharacterPair(s));
     }
 
-    @ProxyMethod({
+    @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true
+        isMatrix: true,
+        parameterDescriptors: [ai82SWithCheckCharacterPairParameterDescriptor]
     })
-    hasValidCheckCharacterPair(
-        @ProxyParameter(ai82SWithCheckCharacterPairParameterDescriptor) matrixSs: Matrix<string>
-    ): MatrixResultError<boolean, ThrowError, TError> {
+    hasValidCheckCharacterPair(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError> {
         return this.mapMatrix(matrixSs, s => hasValidCheckCharacterPair(s));
     }
 }

package/src/gs1/gtin-creator-proxy.ts

@@ -0,0 +1,58 @@
+import type { Nullishable } from "@aidc-toolkit/core";
+import { GTINCreator, type GTINType } from "@aidc-toolkit/gs1";
+import type { AppExtension } from "../app-extension.js";
+import { Types } from "../descriptor.js";
+import { expandParameterDescriptor, proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import { valueParameterDescriptor } from "../utility/transformer-descriptor.js";
+import {
+    indicatorDigitParameterDescriptor,
+    rcnFormatParameterDescriptor,
+    rcnItemReferenceParameterDescriptor,
+    rcnPriceOrWeightParameterDescriptor
+} from "./gtin-descriptor.js";
+import { NumericIdentifierCreatorProxy, sparseParameterDescriptor } from "./identifier-creator-proxy.js";
+import {
+    prefixDefinitionAnyParameterDescriptor,
+    prefixDefinitionGS1UPCParameterDescriptor
+} from "./prefix-definition-descriptor.js";
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GTIN",
+    replaceParameterDescriptors: [
+        {
+            name: expandParameterDescriptor(prefixDefinitionGS1UPCParameterDescriptor).name,
+            replacement: prefixDefinitionAnyParameterDescriptor
+        }
+    ]
+})
+export class GTINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, GTINType, GTINCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gtinCreator);
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        ignoreInfix: true,
+        parameterDescriptors: [indicatorDigitParameterDescriptor, prefixDefinitionAnyParameterDescriptor, valueParameterDescriptor, sparseParameterDescriptor]
+    })
+    createGTIN14(indicatorDigit: string, prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError> {
+        const creator = this.getCreator(prefixDefinition);
+
+        const sparseOrUndefined = sparse ?? undefined;
+
+        return this.mapMatrix(matrixValues, value => creator.createGTIN14(indicatorDigit, value, sparseOrUndefined));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        ignoreInfix: true,
+        parameterDescriptors: [rcnFormatParameterDescriptor, rcnItemReferenceParameterDescriptor, rcnPriceOrWeightParameterDescriptor]
+    })
+    createVariableMeasureRCN(format: string, itemReference: number, matrixPricesOrWeights: Matrix<number>): MatrixResultError<string, ThrowError, TError> {
+        return this.mapMatrix(matrixPricesOrWeights, priceOrWeight => GTINCreator.createVariableMeasureRCN(format, itemReference, priceOrWeight));
+    }
+}

package/src/gs1/gtin-descriptor.ts

@@ -0,0 +1,29 @@
+import { type ParameterDescriptor, Types } from "../descriptor.js";
+
+export const indicatorDigitParameterDescriptor: ParameterDescriptor = {
+    name: "indicatorDigit",
+    type: Types.String,
+    isMatrix: false,
+    isRequired: true
+};
+
+export const rcnFormatParameterDescriptor: ParameterDescriptor = {
+    name: "rcnFormat",
+    type: Types.String,
+    isMatrix: false,
+    isRequired: true
+};
+
+export const rcnItemReferenceParameterDescriptor: ParameterDescriptor = {
+    name: "rcnItemReference",
+    type: Types.Number,
+    isMatrix: false,
+    isRequired: true
+};
+
+export const rcnPriceOrWeightParameterDescriptor: ParameterDescriptor = {
+    name: "rcnPriceOrWeight",
+    type: Types.Number,
+    isMatrix: true,
+    isRequired: true
+};

package/src/gs1/gtin-validator-proxy.ts

@@ -0,0 +1,161 @@
+import type { Nullishable } from "@aidc-toolkit/core";
+import { GTINLengths, type GTINLevel, GTINValidator, IdentifierValidators } from "@aidc-toolkit/gs1";
+import type { AppExtension } from "../app-extension.js";
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import { indicatorDigitParameterDescriptor, rcnFormatParameterDescriptor } from "./gtin-descriptor.js";
+import { GTINValidatorProxy, identifierParameterDescriptor } from "./identifier-validator-proxy.js";
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GTIN13"
+})
+export class GTIN13ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN13]);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GTIN12"
+})
+export class GTIN12ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN12]);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GTIN8"
+})
+export class GTIN8ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN8]);
+    }
+}
+
+const zeroSuppressibleGTIN12ParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "zeroSuppressibleGTIN12"
+};
+
+const zeroSuppressedGTIN12ParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "zeroSuppressedGTIN12"
+};
+
+const convertGTINParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "convertGTIN"
+};
+
+const normalizeGTINParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "normalizeGTIN"
+};
+
+const validateGTINParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "validateGTIN"
+};
+
+const gtinLevelParameterDescriptor: ParameterDescriptor = {
+    name: "gtinLevel",
+    type: Types.Number,
+    isMatrix: false,
+    isRequired: false
+};
+
+const validateGTIN14ParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "validateGTIN14"
+};
+
+const rcnParameterDescriptor: ParameterDescriptor = {
+    name: "rcn",
+    type: Types.String,
+    isMatrix: true,
+    isRequired: true
+};
+
+@proxy.describeClass(false, {
+    namespace: "GS1"
+})
+export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [zeroSuppressibleGTIN12ParameterDescriptor]
+    })
+    zeroSuppressGTIN12(matrixGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        return this.mapMatrix(matrixGTIN12s, gtin12 => GTINValidator.zeroSuppress(gtin12));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [zeroSuppressedGTIN12ParameterDescriptor]
+    })
+    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        return this.mapMatrix(matrixZeroSuppressedGTIN12s, zeroSuppressedGTIN12 => GTINValidator.zeroExpand(zeroSuppressedGTIN12));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [indicatorDigitParameterDescriptor, convertGTINParameterDescriptor]
+    })
+    convertToGTIN14(indicatorDigit: string, matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.convertToGTIN14(indicatorDigit, gtin));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [normalizeGTINParameterDescriptor]
+    })
+    normalizeGTIN(matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.normalize(gtin));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
+    })
+    validateGTIN(matrixGTINs: Matrix<string>, gtinLevel: Nullishable<GTINLevel>): Matrix<string> {
+        const gtinLevelOrUndefined = gtinLevel ?? undefined;
+
+        return LibProxy.mapMatrixRangeError(matrixGTINs, (gtin) => {
+            GTINValidator.validateAny(gtin, gtinLevelOrUndefined);
+        });
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [validateGTIN14ParameterDescriptor]
+    })
+    validateGTIN14(matrixGTIN14s: Matrix<string>): Matrix<string> {
+        return LibProxy.mapMatrixRangeError(matrixGTIN14s, (gtin14) => {
+            GTINValidator.validateGTIN14(gtin14);
+        });
+    }
+
+    @proxy.describeMethod({
+        type: Types.Number,
+        isMatrix: true,
+        parameterDescriptors: [rcnFormatParameterDescriptor, rcnParameterDescriptor]
+    })
+    parseVariableMeasureRCN(format: string, matrixRCNs: Matrix<string>): MatrixResultError<number, ThrowError, TError> {
+        return this.mapArray(matrixRCNs, (rcn) => {
+            const rcnReference = GTINValidator.parseVariableMeasureRCN(format, rcn);
+
+            return [rcnReference.itemReference, rcnReference.priceOrWeight];
+        });
+    }
+}

package/src/gs1/identifier-creator-proxy.ts

@@ -0,0 +1,227 @@
+import { isNullish, type Nullishable } from "@aidc-toolkit/core";
+import {
+    type IdentifierCreator,
+    type IdentifierType,
+    type IdentifierValidation,
+    type NonGTINNumericIdentifierCreator,
+    type NonGTINNumericIdentifierType,
+    type NonNumericIdentifierCreator,
+    type NonNumericIdentifierType,
+    type NonNumericIdentifierValidation,
+    type NonSerializableNumericIdentifierType,
+    type NumericIdentifierCreator,
+    type NumericIdentifierType,
+    type NumericIdentifierValidation,
+    PrefixManager,
+    type PrefixType,
+    PrefixTypes,
+    PrefixValidator,
+    type SerializableNumericIdentifierCreator,
+    type SerializableNumericIdentifierType
+} from "@aidc-toolkit/gs1";
+import { Sequence } from "@aidc-toolkit/utility";
+import type { AppExtension } from "../app-extension.js";
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { i18nextAppExtension } from "../locale/i18n.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import {
+    countParameterDescriptor,
+    startValueParameterDescriptor,
+    valueParameterDescriptor
+} from "../utility/transformer-descriptor.js";
+import { identifierParameterDescriptor } from "./identifier-validator-proxy.js";
+import { prefixDefinitionGS1UPCParameterDescriptor } from "./prefix-definition-descriptor.js";
+
+abstract class IdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TIdentifierType extends IdentifierType, TIdentifierValidation extends IdentifierValidation, TIdentifierCreator extends IdentifierCreator<TIdentifierType, TIdentifierValidation>> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    static readonly #PREFIX_TYPES: Array<PrefixType | undefined> = [PrefixTypes.GS1CompanyPrefix, PrefixTypes.UPCCompanyPrefix, PrefixTypes.GS18Prefix];
+
+    readonly #getCreator: (prefixManager: PrefixManager) => TIdentifierCreator;
+
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, getCreator: (prefixManager: PrefixManager) => TIdentifierCreator) {
+        super(appExtension);
+
+        this.#getCreator = getCreator;
+    }
+
+    protected getCreator(prefixDefinition: Matrix<unknown>): TIdentifierCreator {
+        const reducedPrefixDefinition = prefixDefinition.length === 1 ?
+            // Prefix definition is horizontal.
+            prefixDefinition[0] :
+            // Prefix definition is vertical.
+            prefixDefinition.map((prefixDefinitionRow) => {
+                if (prefixDefinitionRow.length !== 1) {
+                    throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixDefinitionMustBeOneDimensional"));
+                }
+
+                return prefixDefinitionRow[0];
+            });
+
+        if (reducedPrefixDefinition.length > 3) {
+            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixDefinitionMustHaveMaximumThreeElements"));
+        }
+        const prefix = reducedPrefixDefinition[0];
+
+        if (typeof prefix !== "string") {
+            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixMustBeString"));
+        }
+
+        const prefixTypeIndex = reducedPrefixDefinition[1] ?? 0;
+
+        if (typeof prefixTypeIndex !== "number" || prefixTypeIndex < 0 || prefixTypeIndex >= IdentifierCreatorProxy.#PREFIX_TYPES.length) {
+            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixTypeMustBeNumber", {
+                maximumPrefixType: IdentifierCreatorProxy.#PREFIX_TYPES.length - 1
+            }));
+        }
+
+        const prefixType = IdentifierCreatorProxy.#PREFIX_TYPES[prefixTypeIndex];
+
+        // Undefined is included in type in case of invalid input.
+        if (prefixType === undefined) {
+            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.invalidPrefixType"));
+        }
+
+        const prefixManager = PrefixManager.get(prefixType, prefix);
+
+        const tweakFactor = reducedPrefixDefinition[2];
+
+        if (!isNullish(tweakFactor)) {
+            if (typeof tweakFactor !== "number") {
+                throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.tweakFactorMustBeNumber"));
+            }
+
+            prefixManager.tweakFactor = tweakFactor;
+        } else {
+            prefixManager.resetTweakFactor();
+        }
+
+        return this.#getCreator(prefixManager);
+    }
+}
+
+export const sparseParameterDescriptor: ParameterDescriptor = {
+    name: "sparse",
+    type: Types.Boolean,
+    isMatrix: false,
+    isRequired: false
+};
+
+@proxy.describeClass(true, {
+    namespace: "GS1"
+})
+export abstract class NumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNumericIdentifierType extends NumericIdentifierType, TNumericIdentifierCreator extends NumericIdentifierCreator<TNumericIdentifierType>> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNumericIdentifierType, NumericIdentifierValidation, TNumericIdentifierCreator> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, valueParameterDescriptor, sparseParameterDescriptor]
+    })
+    create(prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError> {
+        const creator = this.getCreator(prefixDefinition);
+
+        const sparseOrUndefined = sparse ?? undefined;
+
+        return this.mapMatrix(matrixValues, value => creator.create(value, sparseOrUndefined));
+    }
+
+    @proxy.describeMethod({
+        infixBefore: "Sequence",
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, sparseParameterDescriptor]
+    })
+    createSequence(prefixDefinition: Matrix<unknown>, startValue: number, count: number, sparse: Nullishable<boolean>): Matrix<string> {
+        this.appExtension.validateSequenceCount(count);
+
+        return LibProxy.matrixResult(this.getCreator(prefixDefinition).create(new Sequence(startValue, count), sparse ?? undefined));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor]
+    })
+    createAll(prefixDefinition: Matrix<unknown>): Matrix<string> {
+        const creator = this.getCreator(prefixDefinition);
+
+        this.appExtension.validateSequenceCount(creator.capacity);
+
+        return LibProxy.matrixResult(creator.createAll());
+    }
+}
+
+abstract class NonGTINNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType, TNonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNonGTINNumericIdentifierType, TNonGTINNumericIdentifierCreator> {
+}
+
+export abstract class NonSerializableNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNonSerializableNumericIdentifierType extends NonSerializableNumericIdentifierType, TNonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNonSerializableNumericIdentifierType, TNonGTINNumericIdentifierCreator> {
+}
+
+const singleValueParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: valueParameterDescriptor,
+    isMatrix: false
+};
+
+const baseIdentifierParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "baseIdentifier",
+    isMatrix: false
+};
+
+const serialComponentParameterDescriptor: ParameterDescriptor = {
+    name: "serialComponent",
+    type: Types.String,
+    isMatrix: true,
+    isRequired: true
+};
+
+@proxy.describeClass(true, {
+    namespace: "GS1"
+})
+export abstract class SerializableNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, SerializableNumericIdentifierType, SerializableNumericIdentifierCreator> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, singleValueParameterDescriptor, serialComponentParameterDescriptor, sparseParameterDescriptor]
+    })
+    createSerialized(prefixDefinition: Matrix<unknown>, value: number, matrixSerialComponents: Matrix<string>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError> {
+        const creator = this.getCreator(prefixDefinition);
+
+        const sparseOrUndefined = sparse ?? undefined;
+
+        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.createSerialized(value, serialComponent, sparseOrUndefined));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [baseIdentifierParameterDescriptor, serialComponentParameterDescriptor]
+    })
+    concatenate(baseIdentifier: string, matrixSerialComponents: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        const creator = this.getCreator([[baseIdentifier.substring(0, !baseIdentifier.startsWith("0") ? PrefixValidator.GS1_COMPANY_PREFIX_MINIMUM_LENGTH : PrefixValidator.UPC_COMPANY_PREFIX_MINIMUM_LENGTH + 1), PrefixTypes.GS1CompanyPrefix]]);
+
+        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.concatenate(baseIdentifier, serialComponent));
+    }
+}
+
+const referenceParameterDescriptor: ParameterDescriptor = {
+    name: "reference",
+    type: Types.String,
+    isMatrix: true,
+    isRequired: true
+};
+
+@proxy.describeClass(true, {
+    namespace: "GS1"
+})
+export abstract class NonNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonNumericIdentifierType, NonNumericIdentifierValidation, NonNumericIdentifierCreator> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, referenceParameterDescriptor]
+    })
+    create(prefixDefinition: Matrix<unknown>, matrixReferences: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        const creator = this.getCreator(prefixDefinition);
+
+        return this.mapMatrix(matrixReferences, reference => creator.create(reference));
+    }
+}