@aidc-toolkit/app-extension 1.0.31-beta → 1.0.33-beta

package/src/gs1/check-proxy.ts

@@ -6,15 +6,15 @@ import {
     isValidPriceOrWeightCheckDigit,
     priceOrWeightCheckDigit
 } from "@aidc-toolkit/gs1";
-import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+import { type ExtendsParameterDescriptor, Multiplicities, 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";
+import type { ErrorExtends, Matrix, MatrixResult, SingletonResult } from "../type.js";
 
 const checkSParameterDescriptor: ParameterDescriptor = {
     name: "checkS",
     type: Types.String,
-    isMatrix: true,
+    multiplicity: Multiplicities.Matrix,
     isRequired: true
 };
 
@@ -39,7 +39,7 @@ const checkDigitParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: numericSParameterDescriptor,
     sortOrder: 2,
     name: "checkDigit",
-    isMatrix: false
+    multiplicity: Multiplicities.Singleton
 };
 
 const ai82SParameterDescriptor: ExtendsParameterDescriptor = {
@@ -53,63 +53,64 @@ const ai82SWithCheckCharacterPairParameterDescriptor: ExtendsParameterDescriptor
 };
 
 @proxy.describeClass(false, {
-    namespace: "GS1"
+    namespace: "GS1",
+    category: "checkCharacter"
 })
-export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [numericSParameterDescriptor]
     })
-    checkDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixSs, s => checkDigit(s));
+    checkDigit(matrixSs: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixSs, s => checkDigit(s));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [numericSWithCheckDigitParameterDescriptor]
     })
-    hasValidCheckDigit(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError> {
-        return this.mapMatrix(matrixSs, s => hasValidCheckDigit(s));
+    hasValidCheckDigit(matrixSs: Matrix<string>): MatrixResult<boolean, ThrowError, TError> {
+        return this.matrixResult(matrixSs, s => hasValidCheckDigit(s));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [numericSFourOrFiveDigitsParameterDescriptor]
     })
-    priceOrWeightCheckDigit(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixSs, s => priceOrWeightCheckDigit(s));
+    priceOrWeightCheckDigit(matrixSs: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixSs, s => priceOrWeightCheckDigit(s));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: false,
+        multiplicity: Multiplicities.Singleton,
         parameterDescriptors: [{
             ...numericSFourOrFiveDigitsParameterDescriptor,
-            isMatrix: false
+            multiplicity: Multiplicities.Singleton
         }, checkDigitParameterDescriptor]
     })
-    isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): ResultError<boolean, ThrowError, TError> {
-        return isValidPriceOrWeightCheckDigit(s, checkDigit);
+    isValidPriceOrWeightCheckDigit(s: string, checkDigit: string): SingletonResult<boolean, ThrowError, TError> {
+        return this.singletonResult(() => isValidPriceOrWeightCheckDigit(s, checkDigit));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [ai82SParameterDescriptor]
     })
-    checkCharacterPair(matrixSs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixSs, s => checkCharacterPair(s));
+    checkCharacterPair(matrixSs: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixSs, s => checkCharacterPair(s));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [ai82SWithCheckCharacterPairParameterDescriptor]
     })
-    hasValidCheckCharacterPair(matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError> {
-        return this.mapMatrix(matrixSs, s => hasValidCheckCharacterPair(s));
+    hasValidCheckCharacterPair(matrixSs: Matrix<string>): MatrixResult<boolean, ThrowError, TError> {
+        return this.matrixResult(matrixSs, s => hasValidCheckCharacterPair(s));
     }
 }

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

@@ -1,16 +1,11 @@
 import type { Nullishable } from "@aidc-toolkit/core";
-import { GTINCreator, type GTINType } from "@aidc-toolkit/gs1";
+import type { GTINCreator, GTINType } from "@aidc-toolkit/gs1";
 import type { AppExtension } from "../app-extension.js";
-import { Types } from "../descriptor.js";
+import { Multiplicities, Types } from "../descriptor.js";
 import { expandParameterDescriptor, proxy } from "../proxy.js";
-import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
 import { valueParameterDescriptor } from "../utility/transformer-descriptor.js";
-import {
-    indicatorDigitParameterDescriptor,
-    rcnFormatParameterDescriptor,
-    rcnItemReferenceParameterDescriptor,
-    rcnPriceOrWeightParameterDescriptor
-} from "./gtin-descriptor.js";
+import { indicatorDigitParameterDescriptor } from "./gtin-descriptor.js";
 import { NumericIdentifierCreatorProxy, sparseParameterDescriptor } from "./identifier-creator-proxy.js";
 import {
     prefixDefinitionAnyParameterDescriptor,
@@ -18,41 +13,32 @@ import {
 } from "./prefix-definition-descriptor.js";
 
 @proxy.describeClass(false, {
-    namespace: "GS1",
     methodInfix: "GTIN",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             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>) {
+export class GTINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, GTINType, GTINCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, prefixManager => prefixManager.gtinCreator);
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         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);
-
+    createGTIN14(indicatorDigit: string, prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResult<string, ThrowError, TError> {
         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));
+        return this.setUpMatrixResult(() =>
+            this.getCreator(prefixDefinition),
+        matrixValues, (creator, value) =>
+            creator.createGTIN14(indicatorDigit, value, sparseOrUndefined)
+        );
     }
 }

package/src/gs1/gtin-descriptor.ts

@@ -1,29 +1,8 @@
-import { type ParameterDescriptor, Types } from "../descriptor.js";
+import { Multiplicities, 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,
+    multiplicity: Multiplicities.Singleton,
     isRequired: true
 };

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

@@ -1,39 +1,37 @@
 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 { type ExtendsParameterDescriptor, Multiplicities, 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";
+import type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
+import { indicatorDigitParameterDescriptor } from "./gtin-descriptor.js";
+import { identifierParameterDescriptor } from "./identifier-descriptor.js";
+import { GTINValidatorProxy } 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>) {
+export class GTIN13ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, 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>) {
+export class GTIN12ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, 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>) {
+export class GTIN8ValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends GTINValidatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN8]);
     }
 }
@@ -66,7 +64,7 @@ const validateGTINParameterDescriptor: ExtendsParameterDescriptor = {
 const gtinLevelParameterDescriptor: ParameterDescriptor = {
     name: "gtinLevel",
     type: Types.Number,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     isRequired: false
 };
 
@@ -75,87 +73,86 @@ const validateGTIN14ParameterDescriptor: ExtendsParameterDescriptor = {
     name: "validateGTIN14"
 };
 
-const rcnParameterDescriptor: ParameterDescriptor = {
-    name: "rcn",
-    type: Types.String,
-    isMatrix: true,
-    isRequired: true
-};
-
 @proxy.describeClass(false, {
-    namespace: "GS1"
+    namespace: "GS1",
+    category: "identifierValidation"
 })
-export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [zeroSuppressibleGTIN12ParameterDescriptor]
     })
-    zeroSuppressGTIN12(matrixGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixGTIN12s, gtin12 => GTINValidator.zeroSuppress(gtin12));
+    zeroSuppressGTIN12(matrixGTIN12s: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixGTIN12s, gtin12 => GTINValidator.zeroSuppress(gtin12));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [zeroSuppressedGTIN12ParameterDescriptor]
     })
-    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixZeroSuppressedGTIN12s, zeroSuppressedGTIN12 => GTINValidator.zeroExpand(zeroSuppressedGTIN12));
+    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixZeroSuppressedGTIN12s, zeroSuppressedGTIN12 => GTINValidator.zeroExpand(zeroSuppressedGTIN12));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [indicatorDigitParameterDescriptor, convertGTINParameterDescriptor]
     })
-    convertToGTIN14(indicatorDigit: string, matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.convertToGTIN14(indicatorDigit, gtin));
+    convertToGTIN14(indicatorDigit: string, matrixGTINs: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixGTINs, gtin => GTINValidator.convertToGTIN14(indicatorDigit, gtin));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [normalizeGTINParameterDescriptor]
     })
-    normalizeGTIN(matrixGTINs: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
-        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.normalize(gtin));
+    normalizeGTIN(matrixGTINs: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixGTINs, gtin => GTINValidator.normalize(gtin));
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
     })
     validateGTIN(matrixGTINs: Matrix<string>, gtinLevel: Nullishable<GTINLevel>): Matrix<string> {
         const gtinLevelOrUndefined = gtinLevel ?? undefined;
 
-        return LibProxy.mapMatrixRangeError(matrixGTINs, (gtin) => {
+        return this.matrixErrorResult(matrixGTINs, (gtin) => {
             GTINValidator.validateAny(gtin, gtinLevelOrUndefined);
         });
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
+        parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
+    })
+    isValidGTIN(matrixGTINs: Matrix<string>, gtinLevel: Nullishable<GTINLevel>): Matrix<boolean> {
+        return this.isValidString(this.validateGTIN(matrixGTINs, gtinLevel));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTIN14ParameterDescriptor]
     })
     validateGTIN14(matrixGTIN14s: Matrix<string>): Matrix<string> {
-        return LibProxy.mapMatrixRangeError(matrixGTIN14s, (gtin14) => {
+        return this.matrixErrorResult(matrixGTIN14s, (gtin14) => {
             GTINValidator.validateGTIN14(gtin14);
         });
     }
 
     @proxy.describeMethod({
-        type: Types.Number,
-        isMatrix: true,
-        parameterDescriptors: [rcnFormatParameterDescriptor, rcnParameterDescriptor]
+        type: Types.String,
+        multiplicity: Multiplicities.Matrix,
+        parameterDescriptors: [validateGTIN14ParameterDescriptor]
     })
-    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];
-        });
+    isValidGTIN14(matrixGTIN14s: Matrix<string>): Matrix<boolean> {
+        return this.isValidString(this.validateGTIN14(matrixGTIN14s));
     }
 }

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

@@ -21,25 +21,29 @@ import {
 } 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 { type ExtendsParameterDescriptor, Multiplicities, 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 type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
 import {
     countParameterDescriptor,
     startValueParameterDescriptor,
     valueParameterDescriptor
 } from "../utility/transformer-descriptor.js";
-import { identifierParameterDescriptor } from "./identifier-validator-proxy.js";
+import { identifierParameterDescriptor } from "./identifier-descriptor.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> {
+@proxy.describeClass(true, {
+    namespace: "GS1",
+    category: "identifierCreation"
+})
+abstract class IdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt, TIdentifierType extends IdentifierType, TIdentifierValidation extends IdentifierValidation, TIdentifierCreator extends IdentifierCreator<TIdentifierType, TIdentifierValidation>> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, 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) {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>, getCreator: (prefixManager: PrefixManager) => TIdentifierCreator) {
         super(appExtension);
 
         this.#getCreator = getCreator;
@@ -103,125 +107,131 @@ abstract class IdentifierCreatorProxy<ThrowError extends boolean, TError extends
 export const sparseParameterDescriptor: ParameterDescriptor = {
     name: "sparse",
     type: Types.Boolean,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     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.describeClass(true)
+export abstract class NumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt, TNumericIdentifierType extends NumericIdentifierType, TNumericIdentifierCreator extends NumericIdentifierCreator<TNumericIdentifierType>> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, TNumericIdentifierType, NumericIdentifierValidation, TNumericIdentifierCreator> {
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, valueParameterDescriptor, sparseParameterDescriptor]
     })
-    create(prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResultError<string, ThrowError, TError> {
-        const creator = this.getCreator(prefixDefinition);
-
+    create(prefixDefinition: Matrix<unknown>, matrixValues: Matrix<number | bigint>, sparse: Nullishable<boolean>): MatrixResult<string, ThrowError, TError> {
         const sparseOrUndefined = sparse ?? undefined;
 
-        return this.mapMatrix(matrixValues, value => creator.create(value, sparseOrUndefined));
+        return this.setUpMatrixResult(() =>
+            this.getCreator(prefixDefinition),
+        matrixValues, (creator, value) =>
+            creator.create(value, sparseOrUndefined)
+        );
     }
 
     @proxy.describeMethod({
         infixBefore: "Sequence",
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Array,
         parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, sparseParameterDescriptor]
     })
-    createSequence(prefixDefinition: Matrix<unknown>, startValue: number, count: number, sparse: Nullishable<boolean>): Matrix<string> {
-        this.appExtension.validateSequenceCount(count);
+    createSequence(prefixDefinition: Matrix<unknown>, startValue: number, count: number, sparse: Nullishable<boolean>): MatrixResult<string, ThrowError, TError> {
+        return this.iterableResult(() => {
+            this.appExtension.validateSequenceCount(count);
 
-        return LibProxy.matrixResult(this.getCreator(prefixDefinition).create(new Sequence(startValue, count), sparse ?? undefined));
+            return this.getCreator(prefixDefinition).create(new Sequence(startValue, count), sparse ?? undefined);
+        });
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Array,
         parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor]
     })
-    createAll(prefixDefinition: Matrix<unknown>): Matrix<string> {
-        const creator = this.getCreator(prefixDefinition);
+    createAll(prefixDefinition: Matrix<unknown>): MatrixResult<string, ThrowError, TError> {
+        return this.iterableResult(() => {
+            const creator = this.getCreator(prefixDefinition);
 
-        this.appExtension.validateSequenceCount(creator.capacity);
+            this.appExtension.validateSequenceCount(creator.capacity);
 
-        return LibProxy.matrixResult(creator.createAll());
+            return 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> {
+abstract class NonGTINNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt, TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType, TNonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator> extends NumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, 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> {
+export abstract class NonSerializableNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt, TNonSerializableNumericIdentifierType extends NonSerializableNumericIdentifierType, TNonGTINNumericIdentifierCreator extends NonGTINNumericIdentifierCreator> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, TNonSerializableNumericIdentifierType, TNonGTINNumericIdentifierCreator> {
 }
 
 const singleValueParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: valueParameterDescriptor,
-    isMatrix: false
+    multiplicity: Multiplicities.Singleton
 };
 
 const baseIdentifierParameterDescriptor: ExtendsParameterDescriptor = {
     extendsDescriptor: identifierParameterDescriptor,
     name: "baseIdentifier",
-    isMatrix: false
+    multiplicity: Multiplicities.Singleton
 };
 
 const serialComponentParameterDescriptor: ParameterDescriptor = {
     name: "serialComponent",
     type: Types.String,
-    isMatrix: true,
+    multiplicity: Multiplicities.Matrix,
     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.describeClass(true)
+export abstract class SerializableNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends NonGTINNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, SerializableNumericIdentifierType, SerializableNumericIdentifierCreator> {
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         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);
-
+    createSerialized(prefixDefinition: Matrix<unknown>, value: number, matrixSerialComponents: Matrix<string>, sparse: Nullishable<boolean>): MatrixResult<string, ThrowError, TError> {
         const sparseOrUndefined = sparse ?? undefined;
 
-        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.createSerialized(value, serialComponent, sparseOrUndefined));
+        return this.setUpMatrixResult(() =>
+            this.getCreator(prefixDefinition),
+        matrixSerialComponents, (creator, serialComponent) =>
+            creator.createSerialized(value, serialComponent, sparseOrUndefined)
+        );
     }
 
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         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));
+    concatenate(baseIdentifier: string, matrixSerialComponents: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.setUpMatrixResult(() =>
+            this.getCreator([[baseIdentifier.substring(0, !baseIdentifier.startsWith("0") ? PrefixValidator.GS1_COMPANY_PREFIX_MINIMUM_LENGTH : PrefixValidator.UPC_COMPANY_PREFIX_MINIMUM_LENGTH + 1), PrefixTypes.GS1CompanyPrefix]]),
+        matrixSerialComponents, (creator, serialComponent) =>
+            creator.concatenate(baseIdentifier, serialComponent)
+        );
     }
 }
 
 const referenceParameterDescriptor: ParameterDescriptor = {
     name: "reference",
     type: Types.String,
-    isMatrix: true,
+    multiplicity: Multiplicities.Matrix,
     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.describeClass(true)
+export abstract class NonNumericIdentifierCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends IdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, NonNumericIdentifierType, NonNumericIdentifierValidation, NonNumericIdentifierCreator> {
     @proxy.describeMethod({
         type: Types.String,
-        isMatrix: true,
+        multiplicity: Multiplicities.Matrix,
         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));
+    create(prefixDefinition: Matrix<unknown>, matrixReferences: Matrix<string>): MatrixResult<string, ThrowError, TError> {
+        return this.setUpMatrixResult(() =>
+            this.getCreator(prefixDefinition),
+        matrixReferences, (creator, reference) =>
+            creator.create(reference)
+        );
     }
 }

package/src/gs1/identifier-descriptor.ts

@@ -0,0 +1,15 @@
+import { Multiplicities, type ParameterDescriptor, Types } from "../descriptor.js";
+
+export const identifierTypeParameterDescriptor: ParameterDescriptor = {
+    name: "identifierType",
+    type: Types.String,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: true
+};
+
+export const identifierParameterDescriptor: ParameterDescriptor = {
+    name: "identifier",
+    type: Types.String,
+    multiplicity: Multiplicities.Matrix,
+    isRequired: true
+};