@aidc-toolkit/app-extension 0.9.19-beta

package/dist/gs1/idkey-proxy.js

@@ -0,0 +1,779 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { CPID_VALIDATOR, GCN_VALIDATOR, GDTI_VALIDATOR, GIAI_VALIDATOR, GINC_VALIDATOR, GLN_VALIDATOR, GMN_VALIDATOR, GRAI_VALIDATOR, GSIN_VALIDATOR, GSRN_VALIDATOR, GTIN12_VALIDATOR, GTIN13_VALIDATOR, GTIN8_VALIDATOR, GTINCreator, GTINValidator, PrefixManager, PrefixType, SSCC_VALIDATOR } from "@aidc-toolkit/gs1";
+import { Sequence } from "@aidc-toolkit/utility";
+import { expandParameterDescriptor, ProxyClass, ProxyMethod, ProxyParameter, Type } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { i18nextAppExtension } from "../locale/i18n.js";
+import { isNullish } from "../types.js";
+import { exclusionAllNumericParameterDescriptor } from "../utility/character-set-descriptor.js";
+import { StringProxy } from "../utility/string-proxy.js";
+import { countParameterDescriptor, startValueParameterDescriptor, valueParameterDescriptor } from "../utility/transformer-descriptor.js";
+const identificationKeyParameterDescriptor = {
+    name: "identificationKey",
+    type: Type.String,
+    isMatrix: true,
+    isRequired: true
+};
+const validateIdentificationKeyParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    sortOrder: 0,
+    name: "validateIdentificationKey"
+};
+class IdentificationKeyValidatorProxy extends StringProxy {
+    _validator;
+    constructor(appExtension, validator) {
+        super(appExtension);
+        this._validator = validator;
+    }
+    get validator() {
+        return this._validator;
+    }
+}
+class NumericIdentificationKeyValidatorProxy extends IdentificationKeyValidatorProxy {
+    validate(matrixIdentificationKeys) {
+        return this.validateString(this.validator, matrixIdentificationKeys);
+    }
+}
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(validateIdentificationKeyParameterDescriptor))
+], NumericIdentificationKeyValidatorProxy.prototype, "validate", null);
+class GTINValidatorProxy extends NumericIdentificationKeyValidatorProxy {
+}
+class NonGTINNumericIdentificationKeyValidatorProxy extends NumericIdentificationKeyValidatorProxy {
+}
+class SerializableNumericIdentificationKeyValidatorProxy extends NonGTINNumericIdentificationKeyValidatorProxy {
+}
+class NonNumericIdentificationKeyValidatorProxy extends IdentificationKeyValidatorProxy {
+    validate(matrixIdentificationKeys, exclusion) {
+        return this.validateString(this.validator, matrixIdentificationKeys, {
+            exclusion: exclusion ?? undefined
+        });
+    }
+}
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(validateIdentificationKeyParameterDescriptor)),
+    __param(1, ProxyParameter(exclusionAllNumericParameterDescriptor))
+], NonNumericIdentificationKeyValidatorProxy.prototype, "validate", null);
+let GTIN13ValidatorProxy = class GTIN13ValidatorProxy extends GTINValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GTIN13_VALIDATOR);
+    }
+};
+GTIN13ValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GTIN13"
+    })
+], GTIN13ValidatorProxy);
+export { GTIN13ValidatorProxy };
+let GTIN12ValidatorProxy = class GTIN12ValidatorProxy extends GTINValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GTIN12_VALIDATOR);
+    }
+};
+GTIN12ValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GTIN12"
+    })
+], GTIN12ValidatorProxy);
+export { GTIN12ValidatorProxy };
+let GTIN8ValidatorProxy = class GTIN8ValidatorProxy extends GTINValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GTIN8_VALIDATOR);
+    }
+};
+GTIN8ValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GTIN8"
+    })
+], GTIN8ValidatorProxy);
+export { GTIN8ValidatorProxy };
+const zeroSuppressibleGTIN12ParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "zeroSuppressibleGTIN12"
+};
+const zeroSuppressedGTIN12ParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "zeroSuppressedGTIN12"
+};
+const indicatorDigitParameterDescriptor = {
+    name: "indicatorDigit",
+    type: Type.String,
+    isMatrix: false,
+    isRequired: true
+};
+const convertGTINParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "convertGTIN"
+};
+const normalizeGTINParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "normalizeGTIN"
+};
+const validateGTINParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "validateGTIN"
+};
+const gtinLevelParameterDescriptor = {
+    name: "gtinLevel",
+    type: Type.Number,
+    isMatrix: false,
+    isRequired: false
+};
+const validateGTIN14ParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "validateGTIN14"
+};
+const rcnFormatParameterDescriptor = {
+    name: "rcnFormat",
+    type: Type.String,
+    isMatrix: false,
+    isRequired: true
+};
+const rcnParameterDescriptor = {
+    name: "rcn",
+    type: Type.String,
+    isMatrix: true,
+    isRequired: true
+};
+const rcnItemReferenceParameterDescriptor = {
+    name: "rcnItemReference",
+    type: Type.Number,
+    isMatrix: false,
+    isRequired: true
+};
+const rcnPriceOrWeightParameterDescriptor = {
+    name: "rcnPriceOrWeight",
+    type: Type.Number,
+    isMatrix: true,
+    isRequired: true
+};
+let GTINValidatorStaticProxy = class GTINValidatorStaticProxy extends LibProxy {
+    zeroSuppressGTIN12(matrixGTIN12s) {
+        return this.mapMatrix(matrixGTIN12s, gtin12 => GTINValidator.zeroSuppress(gtin12));
+    }
+    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s) {
+        return this.mapMatrix(matrixZeroSuppressedGTIN12s, zeroSuppressedGTIN12 => GTINValidator.zeroExpand(zeroSuppressedGTIN12));
+    }
+    convertToGTIN14(indicatorDigit, matrixGTINs) {
+        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.convertToGTIN14(indicatorDigit, gtin));
+    }
+    normalizeGTIN(matrixGTINs) {
+        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.normalize(gtin));
+    }
+    validateGTIN(matrixGTINs, gtinLevel) {
+        const gtinLevelOrUndefined = gtinLevel ?? undefined;
+        return LibProxy.mapMatrixRangeError(matrixGTINs, (gtin) => {
+            GTINValidator.validateAny(gtin, gtinLevelOrUndefined);
+        });
+    }
+    validateGTIN14(matrixGTIN14s) {
+        return LibProxy.mapMatrixRangeError(matrixGTIN14s, (gtin14) => {
+            GTINValidator.validateGTIN14(gtin14);
+        });
+    }
+    parseVariableMeasureRCN(format, matrixRCNs) {
+        return this.mapArray(matrixRCNs, (rcn) => {
+            const rcnReference = GTINValidator.parseVariableMeasureRCN(format, rcn);
+            return [rcnReference.itemReference, rcnReference.priceOrWeight];
+        });
+    }
+};
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(zeroSuppressibleGTIN12ParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "zeroSuppressGTIN12", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(zeroSuppressedGTIN12ParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "zeroExpandGTIN12", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(indicatorDigitParameterDescriptor)),
+    __param(1, ProxyParameter(convertGTINParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "convertToGTIN14", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(normalizeGTINParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "normalizeGTIN", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(validateGTINParameterDescriptor)),
+    __param(1, ProxyParameter(gtinLevelParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "validateGTIN", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(validateGTIN14ParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "validateGTIN14", null);
+__decorate([
+    ProxyMethod({
+        type: Type.Number,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(rcnFormatParameterDescriptor)),
+    __param(1, ProxyParameter(rcnParameterDescriptor))
+], GTINValidatorStaticProxy.prototype, "parseVariableMeasureRCN", null);
+GTINValidatorStaticProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1"
+    })
+], GTINValidatorStaticProxy);
+export { GTINValidatorStaticProxy };
+let GLNValidatorProxy = class GLNValidatorProxy extends NonGTINNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GLN_VALIDATOR);
+    }
+};
+GLNValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GLN"
+    })
+], GLNValidatorProxy);
+export { GLNValidatorProxy };
+let SSCCValidatorProxy = class SSCCValidatorProxy extends NonGTINNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, SSCC_VALIDATOR);
+    }
+};
+SSCCValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "SSCC"
+    })
+], SSCCValidatorProxy);
+export { SSCCValidatorProxy };
+let GRAIValidatorProxy = class GRAIValidatorProxy extends SerializableNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GRAI_VALIDATOR);
+    }
+};
+GRAIValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GRAI"
+    })
+], GRAIValidatorProxy);
+export { GRAIValidatorProxy };
+let GIAIValidatorProxy = class GIAIValidatorProxy extends NonNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GIAI_VALIDATOR);
+    }
+};
+GIAIValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GIAI"
+    })
+], GIAIValidatorProxy);
+export { GIAIValidatorProxy };
+let GSRNValidatorProxy = class GSRNValidatorProxy extends NonGTINNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GSRN_VALIDATOR);
+    }
+};
+GSRNValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GSRN"
+    })
+], GSRNValidatorProxy);
+export { GSRNValidatorProxy };
+let GDTIValidatorProxy = class GDTIValidatorProxy extends SerializableNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GDTI_VALIDATOR);
+    }
+};
+GDTIValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GDTI"
+    })
+], GDTIValidatorProxy);
+export { GDTIValidatorProxy };
+let GINCValidatorProxy = class GINCValidatorProxy extends NonNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GINC_VALIDATOR);
+    }
+};
+GINCValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GINC"
+    })
+], GINCValidatorProxy);
+export { GINCValidatorProxy };
+let GSINValidatorProxy = class GSINValidatorProxy extends NonGTINNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GSIN_VALIDATOR);
+    }
+};
+GSINValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GSIN"
+    })
+], GSINValidatorProxy);
+export { GSINValidatorProxy };
+let GCNValidatorProxy = class GCNValidatorProxy extends SerializableNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GCN_VALIDATOR);
+    }
+};
+GCNValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GCN"
+    })
+], GCNValidatorProxy);
+export { GCNValidatorProxy };
+let CPIDValidatorProxy = class CPIDValidatorProxy extends NonNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, CPID_VALIDATOR);
+    }
+};
+CPIDValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "CPID"
+    })
+], CPIDValidatorProxy);
+export { CPIDValidatorProxy };
+let GMNValidatorProxy = class GMNValidatorProxy extends NonNumericIdentificationKeyValidatorProxy {
+    constructor(appExtension) {
+        super(appExtension, GMN_VALIDATOR);
+    }
+};
+GMNValidatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GMN"
+    })
+], GMNValidatorProxy);
+export { GMNValidatorProxy };
+const prefixParameterDescriptor = {
+    name: "prefix",
+    type: Type.String,
+    isMatrix: false,
+    isRequired: true
+};
+const prefixTypeParameterDescriptor = {
+    name: "prefixType",
+    type: Type.Number,
+    isMatrix: false,
+    isRequired: false
+};
+const tweakFactorParameterDescriptor = {
+    name: "tweakFactor",
+    type: Type.Number,
+    isMatrix: false,
+    isRequired: false
+};
+const prefixDefinitionParameterDescriptor = {
+    name: "prefixDefinition",
+    type: Type.Any,
+    isMatrix: true,
+    isRequired: true
+};
+const prefixDefinitionGS1UPCParameterDescriptor = {
+    extendsDescriptor: prefixDefinitionParameterDescriptor,
+    name: "prefixDefinitionGS1UPC"
+};
+const prefixDefinitionAnyParameterDescriptor = {
+    extendsDescriptor: prefixDefinitionParameterDescriptor,
+    name: "prefixDefinitionAny"
+};
+let PrefixManagerProxy = class PrefixManagerProxy extends LibProxy {
+    definePrefix(prefix, prefixType, tweakFactor) {
+        // Parameters will be validated by IdentificationKeyCreatorProxy.getCreator().
+        return [[prefix, prefixType, tweakFactor]];
+    }
+};
+__decorate([
+    ProxyMethod({
+        type: Type.Any,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixParameterDescriptor)),
+    __param(1, ProxyParameter(prefixTypeParameterDescriptor)),
+    __param(2, ProxyParameter(tweakFactorParameterDescriptor))
+], PrefixManagerProxy.prototype, "definePrefix", null);
+PrefixManagerProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1"
+    })
+], PrefixManagerProxy);
+export { PrefixManagerProxy };
+class IdentificationKeyCreatorProxy extends LibProxy {
+    _getCreator;
+    constructor(appExtension, getCreator) {
+        super(appExtension);
+        this._getCreator = getCreator;
+    }
+    getCreator(prefixDefinition) {
+        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("IdentificationKeyCreatorProxy.prefixDefinitionMustBeOneDimensional"));
+                }
+                return prefixDefinitionRow[0];
+            });
+        if (reducedPrefixDefinition.length > 3) {
+            throw new RangeError(i18nextAppExtension.t("IdentificationKeyCreatorProxy.prefixDefinitionMustHaveMaximumThreeElements"));
+        }
+        const prefix = reducedPrefixDefinition[0];
+        if (typeof prefix !== "string") {
+            throw new RangeError(i18nextAppExtension.t("IdentificationKeyCreatorProxy.prefixMustBeString"));
+        }
+        const prefixType = reducedPrefixDefinition[1] ?? PrefixType.GS1CompanyPrefix;
+        if (typeof prefixType !== "number") {
+            throw new RangeError(i18nextAppExtension.t("IdentificationKeyCreatorProxy.prefixTypeMustBeNumber"));
+        }
+        const prefixManager = PrefixManager.get(prefixType, prefix);
+        const tweakFactor = reducedPrefixDefinition[2];
+        if (!isNullish(tweakFactor)) {
+            if (typeof tweakFactor !== "number") {
+                throw new RangeError(i18nextAppExtension.t("IdentificationKeyCreatorProxy.tweakFactorMustBeNumber"));
+            }
+            prefixManager.tweakFactor = tweakFactor;
+        }
+        else {
+            prefixManager.resetTweakFactor();
+        }
+        return this._getCreator(prefixManager);
+    }
+}
+const sparseParameterDescriptor = {
+    name: "sparse",
+    type: Type.Boolean,
+    isMatrix: false,
+    isRequired: false
+};
+class NumericIdentificationKeyCreatorProxy extends IdentificationKeyCreatorProxy {
+    create(prefixDefinition, matrixValues, sparse) {
+        const creator = this.getCreator(prefixDefinition);
+        const sparseOrUndefined = sparse ?? undefined;
+        return this.mapMatrix(matrixValues, value => creator.create(value, sparseOrUndefined));
+    }
+    createSequence(prefixDefinition, startValue, count, sparse) {
+        this.appExtension.validateSequenceCount(count);
+        return LibProxy.matrixResult(this.getCreator(prefixDefinition).create(new Sequence(startValue, count), sparse ?? undefined));
+    }
+    createAll(prefixDefinition) {
+        const creator = this.getCreator(prefixDefinition);
+        this.appExtension.validateSequenceCount(creator.capacity);
+        return LibProxy.matrixResult(creator.createAll());
+    }
+}
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
+    __param(1, ProxyParameter(valueParameterDescriptor)),
+    __param(2, ProxyParameter(sparseParameterDescriptor))
+], NumericIdentificationKeyCreatorProxy.prototype, "create", null);
+__decorate([
+    ProxyMethod({
+        infixBefore: "Sequence",
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
+    __param(1, ProxyParameter(startValueParameterDescriptor)),
+    __param(2, ProxyParameter(countParameterDescriptor)),
+    __param(3, ProxyParameter(sparseParameterDescriptor))
+], NumericIdentificationKeyCreatorProxy.prototype, "createSequence", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor))
+], NumericIdentificationKeyCreatorProxy.prototype, "createAll", null);
+class NonGTINNumericIdentificationKeyCreatorProxy extends NumericIdentificationKeyCreatorProxy {
+}
+const singleValueParameterDescriptor = {
+    extendsDescriptor: valueParameterDescriptor,
+    isMatrix: false
+};
+const baseIdentificationKeyParameterDescriptor = {
+    extendsDescriptor: identificationKeyParameterDescriptor,
+    name: "baseIdentificationKey",
+    isMatrix: false
+};
+const serialComponentParameterDescriptor = {
+    name: "serialComponent",
+    type: Type.String,
+    isMatrix: true,
+    isRequired: true
+};
+class SerializableNumericIdentificationKeyCreatorProxy extends NonGTINNumericIdentificationKeyCreatorProxy {
+    createSerialized(prefixDefinition, value, matrixSerialComponents, sparse) {
+        const creator = this.getCreator(prefixDefinition);
+        const sparseOrUndefined = sparse ?? undefined;
+        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.createSerialized(value, serialComponent, sparseOrUndefined));
+    }
+    concatenate(baseIdentificationKey, matrixSerialComponents) {
+        const creator = this.getCreator([[baseIdentificationKey.substring(0, !baseIdentificationKey.startsWith("0") ? PrefixManager.GS1_COMPANY_PREFIX_MINIMUM_LENGTH : PrefixManager.UPC_COMPANY_PREFIX_MINIMUM_LENGTH + 1), PrefixType.GS1CompanyPrefix]]);
+        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.concatenate(baseIdentificationKey, serialComponent));
+    }
+}
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
+    __param(1, ProxyParameter(singleValueParameterDescriptor)),
+    __param(2, ProxyParameter(serialComponentParameterDescriptor)),
+    __param(3, ProxyParameter(sparseParameterDescriptor))
+], SerializableNumericIdentificationKeyCreatorProxy.prototype, "createSerialized", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(baseIdentificationKeyParameterDescriptor)),
+    __param(1, ProxyParameter(serialComponentParameterDescriptor))
+], SerializableNumericIdentificationKeyCreatorProxy.prototype, "concatenate", null);
+const referenceParameterDescriptor = {
+    name: "reference",
+    type: Type.String,
+    isMatrix: true,
+    isRequired: true
+};
+class NonNumericIdentificationKeyCreatorProxy extends IdentificationKeyCreatorProxy {
+    create(prefixDefinition, matrixReferences) {
+        const creator = this.getCreator(prefixDefinition);
+        return this.mapMatrix(matrixReferences, reference => creator.create(reference));
+    }
+}
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true
+    }),
+    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
+    __param(1, ProxyParameter(referenceParameterDescriptor))
+], NonNumericIdentificationKeyCreatorProxy.prototype, "create", null);
+let GTINCreatorProxy = class GTINCreatorProxy extends NumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gtinCreator);
+    }
+    createGTIN14(indicatorDigit, prefixDefinition, matrixValues, sparse) {
+        const creator = this.getCreator(prefixDefinition);
+        const sparseOrUndefined = sparse ?? undefined;
+        return this.mapMatrix(matrixValues, value => creator.createGTIN14(indicatorDigit, value, sparseOrUndefined));
+    }
+    createVariableMeasureRCN(format, itemReference, matrixPricesOrWeights) {
+        return this.mapMatrix(matrixPricesOrWeights, priceOrWeight => GTINCreator.createVariableMeasureRCN(format, itemReference, priceOrWeight));
+    }
+};
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true,
+        ignoreInfix: true
+    }),
+    __param(0, ProxyParameter(indicatorDigitParameterDescriptor)),
+    __param(1, ProxyParameter(prefixDefinitionAnyParameterDescriptor)),
+    __param(2, ProxyParameter(valueParameterDescriptor)),
+    __param(3, ProxyParameter(sparseParameterDescriptor))
+], GTINCreatorProxy.prototype, "createGTIN14", null);
+__decorate([
+    ProxyMethod({
+        type: Type.String,
+        isMatrix: true,
+        ignoreInfix: true
+    }),
+    __param(0, ProxyParameter(rcnFormatParameterDescriptor)),
+    __param(1, ProxyParameter(rcnItemReferenceParameterDescriptor)),
+    __param(2, ProxyParameter(rcnPriceOrWeightParameterDescriptor))
+], GTINCreatorProxy.prototype, "createVariableMeasureRCN", null);
+GTINCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GTIN",
+        replaceParameterDescriptors: [
+            {
+                name: expandParameterDescriptor(prefixDefinitionGS1UPCParameterDescriptor).name,
+                replacement: prefixDefinitionAnyParameterDescriptor
+            }
+        ]
+    })
+], GTINCreatorProxy);
+export { GTINCreatorProxy };
+let GLNCreatorProxy = class GLNCreatorProxy extends NonGTINNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.glnCreator);
+    }
+};
+GLNCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GLN"
+    })
+], GLNCreatorProxy);
+export { GLNCreatorProxy };
+let SSCCCreatorProxy = class SSCCCreatorProxy extends NonGTINNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.ssccCreator);
+    }
+};
+SSCCCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "SSCC"
+    })
+], SSCCCreatorProxy);
+export { SSCCCreatorProxy };
+let GRAICreatorProxy = class GRAICreatorProxy extends SerializableNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.graiCreator);
+    }
+};
+GRAICreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GRAI"
+    })
+], GRAICreatorProxy);
+export { GRAICreatorProxy };
+let GIAICreatorProxy = class GIAICreatorProxy extends NonNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.giaiCreator);
+    }
+};
+GIAICreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GIAI"
+    })
+], GIAICreatorProxy);
+export { GIAICreatorProxy };
+let GSRNCreatorProxy = class GSRNCreatorProxy extends NonGTINNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gsrnCreator);
+    }
+};
+GSRNCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GSRN"
+    })
+], GSRNCreatorProxy);
+export { GSRNCreatorProxy };
+let GDTICreatorProxy = class GDTICreatorProxy extends SerializableNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gdtiCreator);
+    }
+};
+GDTICreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GDTI"
+    })
+], GDTICreatorProxy);
+export { GDTICreatorProxy };
+let GINCCreatorProxy = class GINCCreatorProxy extends NonNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gincCreator);
+    }
+};
+GINCCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GINC"
+    })
+], GINCCreatorProxy);
+export { GINCCreatorProxy };
+let GSINCreatorProxy = class GSINCreatorProxy extends NonGTINNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gsinCreator);
+    }
+};
+GSINCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GSIN"
+    })
+], GSINCreatorProxy);
+export { GSINCreatorProxy };
+let GCNCreatorProxy = class GCNCreatorProxy extends SerializableNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gcnCreator);
+    }
+};
+GCNCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GCN"
+    })
+], GCNCreatorProxy);
+export { GCNCreatorProxy };
+let CPIDCreatorProxy = class CPIDCreatorProxy extends NonNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.cpidCreator);
+    }
+};
+CPIDCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "CPID"
+    })
+], CPIDCreatorProxy);
+export { CPIDCreatorProxy };
+let GMNCreatorProxy = class GMNCreatorProxy extends NonNumericIdentificationKeyCreatorProxy {
+    constructor(appExtension) {
+        super(appExtension, prefixManager => prefixManager.gmnCreator);
+    }
+};
+GMNCreatorProxy = __decorate([
+    ProxyClass({
+        namespace: "GS1",
+        methodInfix: "GMN"
+    })
+], GMNCreatorProxy);
+export { GMNCreatorProxy };
+//# sourceMappingURL=idkey-proxy.js.map