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

package/src/generator/generator.ts

@@ -1,17 +1,11 @@
 import { I18nEnvironments } from "@aidc-toolkit/core";
 import type { ParseKeys } from "i18next";
 import { AppUtilityProxy } from "../app-utility-proxy.js";
-import { expandParameterDescriptor, getClassDescriptorsMap } from "../descriptor.js";
+import type { ClassDescriptor, MethodDescriptor } from "../descriptor.js";
 import * as GS1 from "../gs1/index.js";
 import { appExtensionResources, i18nAppExtensionInit, i18nextAppExtension } from "../locale/i18n.js";
+import { proxy } from "../proxy.js";
 import * as Utility from "../utility/index.js";
-import type {
-    FunctionLocalization,
-    Localization,
-    ParameterLocalization,
-    ProxyFunctionDescriptor,
-    ProxyObjectDescriptor
-} from "./descriptor.js";
 
 /**
  * Dummy method to force proxies to register their decorators.
@@ -23,6 +17,35 @@ function registerProxies(..._proxies: unknown[]): void {
 }
 
 registerProxies(AppUtilityProxy, Utility, GS1);
+/**
+ * Localization.
+ */
+export interface Localization {
+    /**
+     * Name.
+     */
+    name: string;
+
+    /**
+     * Description.
+     */
+    description: string;
+}
+
+/**
+ * Function localization.
+ */
+export interface FunctionLocalization extends Localization {
+    /**
+     * Documentation URL.
+     */
+    documentationURL: string;
+
+    /**
+     * Parameters map.
+     */
+    parametersMap: Map<string, Localization>;
+}
 
 /**
  * Abstract generator.
@@ -53,15 +76,6 @@ export abstract class Generator {
      */
     readonly #functionLocalizationsMapsMap = new Map<string, ReadonlyMap<string, FunctionLocalization>>();
 
-    /**
-     * Map of parameter localizations maps by namespace function parameter name.
-     */
-    readonly #parameterLocalizationsMapsMap = new Map<string, ReadonlyMap<string, ParameterLocalization>>();
-
-    /**
-     *
-     */
-
     /**
      * Constructor.
      *
@@ -90,16 +104,16 @@ export abstract class Generator {
     /**
      * Get function localization.
      *
-     * @param namespaceFunctionName
-     * Namespace function name.
-     *
      * @param locale
      * Locale.
      *
+     * @param namespaceFunctionName
+     * Namespace function name.
+     *
      * @returns
      * Function localization.
      */
-    protected getFunctionLocalization(namespaceFunctionName: string, locale: string): FunctionLocalization {
+    protected getFunctionLocalization(locale: string, namespaceFunctionName: string): FunctionLocalization {
         const functionLocalization = this.#functionLocalizationsMapsMap.get(namespaceFunctionName)?.get(locale);
 
         if (functionLocalization === undefined) {
@@ -112,20 +126,20 @@ export abstract class Generator {
     /**
      * Get parameter localization.
      *
+     * @param locale
+     * Locale.
+     *
      * @param namespaceFunctionName
      * Namespace function name.
      *
      * @param parameterName
      * Parameter name.
      *
-     * @param locale
-     * Locale.
-     *
      * @returns
-     * Function localization.
+     * Parameter localization.
      */
-    protected getParameterLocalization(namespaceFunctionName: string, parameterName: string, locale: string): ParameterLocalization {
-        const parameterLocalization = this.#parameterLocalizationsMapsMap.get(`${namespaceFunctionName}.${parameterName}`)?.get(locale);
+    protected getParameterLocalization(locale: string, namespaceFunctionName: string, parameterName: string): Localization {
+        const parameterLocalization = this.getFunctionLocalization(locale, namespaceFunctionName).parametersMap.get(parameterName);
 
         if (parameterLocalization === undefined) {
             throw new Error(`${locale} localization for function ${namespaceFunctionName} parameter ${parameterName} not found`);
@@ -140,20 +154,26 @@ export abstract class Generator {
     protected abstract initialize(): void;
 
     /**
-     * Create a proxy object.
+     * Create a proxy object for a class.
      *
-     * @param proxyObjectDescriptor
-     * Proxy object descriptor.
+     * @param classDescriptor
+     * Class descriptor.
      */
-    protected abstract createProxyObject(proxyObjectDescriptor: ProxyObjectDescriptor): void;
+    protected abstract createProxyObject(classDescriptor: ClassDescriptor): void;
 
     /**
-     * Create a proxy function.
+     * Create a proxy function for a class and method.
+     *
+     * @param classDescriptor
+     * Class descriptor.
+     *
+     * @param methodDescriptor
+     * Method descriptor.
      *
-     * @param proxyFunctionDescriptor
-     * Proxy function descriptor.
+     * @param functionLocalizationsMap
+     * Localizations map.
      */
-    protected abstract createProxyFunction(proxyFunctionDescriptor: ProxyFunctionDescriptor): void;
+    protected abstract createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
 
     /**
      * Finalize the generation of the output.
@@ -164,33 +184,37 @@ export abstract class Generator {
     protected abstract finalize(success: boolean): void | Promise<void>;
 
     /**
-     * Generate localizations map.
+     * Generate a localization.
      *
      * @template TLocalization
      * Localization type.
      *
+     * @param locale
+     * Locale.
+     *
      * @param localizedKeyPrefix
      * Localized key prefix.
      *
+     * @param namespacePrefix
+     * Namespace prefix to be appended to name.
+     *
      * @param localizationCallback
      * Callback to finalize localization.
      *
      * @returns
-     * Localization map.
+     * Localization.
      */
-    #generateLocalizationsMap<TLocalization extends Localization>(localizedKeyPrefix: string, localizationCallback: (locale: string, localization: Localization) => TLocalization): ReadonlyMap<string, TLocalization> {
-        return new Map(this.#locales.map((locale) => {
-            const lngOption = {
-                lng: locale
-            };
-
-            return [locale, localizationCallback(locale, {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
-                name: i18nextAppExtension.t(`${localizedKeyPrefix}name` as ParseKeys, lngOption),
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
-                description: i18nextAppExtension.t(`${localizedKeyPrefix}description` as ParseKeys, lngOption)
-            })];
-        }));
+    #generateLocalization<TLocalization extends Localization>(locale: string, localizedKeyPrefix: string, namespacePrefix: string, localizationCallback: (locale: string, localization: Localization) => TLocalization): TLocalization {
+        const lngOption = {
+            lng: locale
+        };
+
+        return localizationCallback(locale, {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
+            name: `${namespacePrefix}${i18nextAppExtension.t(`${localizedKeyPrefix}name` as ParseKeys, lngOption)}`,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
+            description: i18nextAppExtension.t(`${localizedKeyPrefix}description` as ParseKeys, lngOption)
+        });
     }
 
     /**
@@ -208,95 +232,29 @@ export abstract class Generator {
         this.initialize();
 
         try {
-            for (const classDescriptor of getClassDescriptorsMap().values()) {
+            for (const [_namespaceClassName, classDescriptor] of proxy.classDescriptorsMap.entries()) {
                 const namespace = classDescriptor.namespace;
                 const namespacePrefix = namespace === undefined ? "" : `${namespace}.`;
-                const className = classDescriptor.name;
-                const methodInfix = classDescriptor.methodInfix;
-
-                // Namespace-qualified class name is used to construct object name.
-                const namespaceClassName = `${namespacePrefix}${className}`;
-
-                // First capture group is:
-                // - one or more uppercase letters followed by zero or more numbers; or
-                // - single uppercase letter followed by zero or more characters except uppercase letters or period.
-                // Second capture group is:
-                // - single uppercase letter followed by zero or more characters except period; or
-                // - zero characters (empty string).
-                // Third capture group, separated by optional period, is:
-                // - single uppercase letter followed by zero or more characters (remainder of string); or
-                // - zero characters (empty string).
-                const classNameMatch = /^([A-Z]+[0-9]*|[A-Z][^A-Z.]*)([A-Z][^.]*|)\.?([A-Z].*|)$/.exec(namespaceClassName);
-
-                if (classNameMatch === null) {
-                    throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
-                }
-
-                const proxyObjectDescriptor: ProxyObjectDescriptor = {
-                    namespace,
-                    className,
-                    namespaceClassName,
-                    classDescriptor,
-                    objectName: `${classNameMatch[1].toLowerCase()}${classNameMatch[2]}${classNameMatch[3]}`
-                };
+                const namespacePath = namespace === undefined ? "" : `${namespace}/`;
 
-                this.createProxyObject(proxyObjectDescriptor);
+                this.createProxyObject(classDescriptor);
 
                 for (const methodDescriptor of classDescriptor.methodDescriptors) {
-                    const methodName = methodDescriptor.name;
-                    const infixBefore = methodDescriptor.infixBefore;
-
-                    let functionName: string;
-
-                    if (methodInfix === undefined || methodDescriptor.ignoreInfix === true) {
-                        // No other classes in the hierarchy or no infix required.
-                        functionName = methodName;
-                    } else if (infixBefore === undefined) {
-                        // Other classes in the hierarchy and infix is postfix.
-                        functionName = `${methodName}${methodInfix}`;
-                    } else {
-                        const insertIndex = methodName.indexOf(infixBefore);
-
-                        if (insertIndex === -1) {
-                            throw new Error(`Cannot find "${infixBefore}" in method ${methodName}`);
-                        }
-
-                        // Other classes in the hierarchy and infix is in the middle of the string.
-                        functionName = `${methodName.substring(0, insertIndex)}${methodInfix}${methodName.substring(insertIndex)}`;
-                    }
-
-                    const namespaceFunctionName = `${namespacePrefix}${functionName}`;
-
-                    const functionLocalizationsMap = this.#generateLocalizationsMap<FunctionLocalization>(`Functions.${namespaceFunctionName}.`, (locale, localization) => ({
-                        ...localization,
-                        documentationURL: `${Generator.#DOCUMENTATION_BASE_URL}${locale === this.defaultLocale ? "" : `${locale}/`}${Generator.#DOCUMENTATION_PATH}${namespace === undefined ? "" : `${namespace}/`}${localization.name}.html`
-                    }));
+                    const namespaceFunctionName = methodDescriptor.namespaceFunctionName;
+                    const functionLocalizationsMap = new Map(this.#locales.map(locale =>
+                        [locale, this.#generateLocalization<FunctionLocalization>(locale, `Functions.${namespaceFunctionName}.`, namespacePrefix, (locale, localization) => ({
+                            ...localization,
+                            documentationURL: `${Generator.#DOCUMENTATION_BASE_URL}${locale === this.defaultLocale ? "" : `${locale}/`}${Generator.#DOCUMENTATION_PATH}${namespacePath}${localization.name}.html`,
+                            parametersMap: new Map(methodDescriptor.parameterDescriptors.map(parameterDescriptor =>
+                                // eslint-disable-next-line max-nested-callbacks -- Callback is empty.
+                                [parameterDescriptor.name, this.#generateLocalization(locale, `Parameters.${parameterDescriptor.name}.`, "", (_locale, localization) => localization)]
+                            ))
+                        }))]
+                    ));
 
                     this.#functionLocalizationsMapsMap.set(namespaceFunctionName, functionLocalizationsMap);
 
-                    this.createProxyFunction({
-                        ...proxyObjectDescriptor,
-                        functionName,
-                        namespaceFunctionName,
-                        localizationsMap: functionLocalizationsMap,
-                        proxyParameterDescriptors: methodDescriptor.parameterDescriptors.map((parameterDescriptor) => {
-                            const expandedParameterDescriptor = expandParameterDescriptor(parameterDescriptor);
-
-                            const parameterName = expandedParameterDescriptor.name;
-
-                            const parameterLocalizationsMap = this.#generateLocalizationsMap(`Parameters.${parameterName}.`, (_locale, localization) => localization);
-
-                            this.#parameterLocalizationsMapsMap.set(`${namespaceFunctionName}.${parameterName}`, parameterLocalizationsMap);
-
-                            return {
-                                namespace,
-                                parameterName,
-                                localizationsMap: parameterLocalizationsMap,
-                                parameterDescriptor: expandedParameterDescriptor
-                            };
-                        }),
-                        methodDescriptor
-                    });
+                    this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
                 }
             }
 

package/src/generator/index.ts

@@ -1,2 +1 @@
-export type * from "./descriptor.js";
 export * from "./generator.js";

package/src/generator/locale-resources-generator.ts

@@ -1,8 +1,12 @@
 import { getLogger, type LocaleResources } from "@aidc-toolkit/core";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { expandParameterDescriptor, type ParameterDescriptor } from "../descriptor.js";
-import type { ProxyFunctionDescriptor } from "./descriptor.js";
+import type {
+    ClassDescriptor,
+    ExtendsParameterDescriptor,
+    MethodDescriptor,
+    ParameterDescriptor
+} from "../descriptor.js";
 import { Generator } from "./generator.js";
 
 /**
@@ -17,7 +21,17 @@ interface ParametersSequencerEntry {
     /**
      * Parameter descriptor.
      */
-    parameterDescriptor: ParameterDescriptor;
+    parameterDescriptor: ParameterDescriptor | ExtendsParameterDescriptor;
+
+    /**
+     * Parameter name.
+     */
+    parameterName: string;
+
+    /**
+     * Base parameter name.
+     */
+    baseParameterName: string;
 
     /**
      * True if parameter is actually used and not just a base.
@@ -28,6 +42,7 @@ interface ParametersSequencerEntry {
 /**
  * Parameters sequencer for keeping similar (extended) parameters together.
  */
+// TODO Replace with map.
 type ParametersSequencer = Record<string, ParametersSequencerEntry>;
 
 /**
@@ -108,7 +123,7 @@ class LocaleResourcesGenerator extends Generator {
      * @returns
      * Parameters sequencer entry.
      */
-    #saveParameterSequence(parameterDescriptor: ParameterDescriptor, isUsed: boolean): ParametersSequencerEntry {
+    #saveParameterSequence(parameterDescriptor: ParameterDescriptor | ExtendsParameterDescriptor, isUsed: boolean): ParametersSequencerEntry {
         let parametersSequencerEntry: ParametersSequencerEntry;
 
         if (!("extendsDescriptor" in parameterDescriptor)) {
@@ -119,6 +134,8 @@ class LocaleResourcesGenerator extends Generator {
                 parametersSequencerEntry = {
                     parametersSequencerOrNull: null,
                     parameterDescriptor,
+                    parameterName,
+                    baseParameterName: parameterName,
                     isUsed
                 };
 
@@ -129,10 +146,18 @@ class LocaleResourcesGenerator extends Generator {
         } else {
             const baseParametersSequencerEntry = this.#saveParameterSequence(parameterDescriptor.extendsDescriptor, false);
 
-            const expandedParameterDescriptor = expandParameterDescriptor(parameterDescriptor);
-            const parameterName = expandedParameterDescriptor.name;
+            let parameterName: string;
+            let baseParameterName: string | null;
 
-            if (parameterName !== expandParameterDescriptor(parameterDescriptor.extendsDescriptor).name) {
+            if (parameterDescriptor.name !== undefined) {
+                parameterName = parameterDescriptor.name;
+                baseParameterName = baseParametersSequencerEntry.parameterName;
+            } else {
+                parameterName = baseParametersSequencerEntry.parameterName;
+                baseParameterName = baseParametersSequencerEntry.baseParameterName;
+            }
+
+            if (parameterName !== baseParameterName) {
                 // Make sure that base parameters sequencer entry refers to a record type.
                 baseParametersSequencerEntry.parametersSequencerOrNull ??= {};
 
@@ -140,6 +165,8 @@ class LocaleResourcesGenerator extends Generator {
                     parametersSequencerEntry = {
                         parametersSequencerOrNull: null,
                         parameterDescriptor,
+                        parameterName,
+                        baseParameterName,
                         isUsed
                     };
 
@@ -159,13 +186,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected createProxyFunction(proxyFunctionDescriptor: ProxyFunctionDescriptor): void {
-        const {
-            namespace,
-            functionName,
-            methodDescriptor
-        } = proxyFunctionDescriptor;
-
+    protected createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
         // Add any parameters that are not already known.
         for (const parameterDescriptor of methodDescriptor.parameterDescriptors) {
             this.#saveParameterSequence(parameterDescriptor, true);
@@ -173,6 +194,8 @@ class LocaleResourcesGenerator extends Generator {
 
         let functionsLocaleResources = this.#functionsLocaleResources;
 
+        const namespace = classDescriptor.namespace;
+
         if (namespace !== undefined) {
             if (!(namespace in functionsLocaleResources)) {
                 const namespaceFunctionsLocaleResources: LocaleResources = {};
@@ -187,6 +210,8 @@ class LocaleResourcesGenerator extends Generator {
             }
         }
 
+        const functionName = methodDescriptor.functionName;
+
         if (functionName in functionsLocaleResources) {
             throw new Error(`Duplicate function ${functionName}`);
         }

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));
     }
 }