@aidc-toolkit/app-extension 1.0.48-beta → 1.0.49

package/dist/index.js

@@ -1,3 +1,4 @@
+import{a as b}from"./chunk-MR63TJ3B.js";import{A as y,B as S,C,D as I,E as v,i as c,j as l,k as n,l as p,m as T,n as u,o as E,u as h,w as x,z as d}from"./chunk-22IRLVWO.js";import{getLogger as m,LogLevels as a,MemoryTransport as g}from"@aidc-toolkit/core";var i=class e{static APPLICATION_NAME="AIDCToolkit";static VERSION_NAME=`${e.APPLICATION_NAME}.version`;static#i=120;static#s=100;#t;#r;#o;#e;#n;#a=new WeakMap;constructor(t,r,s){this.#t=t,this.#r=r,this.#o=s;let o=!t.includes("-");this.#e=m(o?a.Info:a.Debug,{type:o?"hidden":"pretty"}),this.#n=new g(this.#e,e.#i,e.#s)}async initialize(){await this.getDocumentProperty(e.VERSION_NAME)!==this.#t&&await this.setDocumentProperty(e.VERSION_NAME,this.#t)}get version(){return this.#t}get throwError(){return this.#o}get logger(){return this.#e}get memoryTransport(){return this.#n}getProxy(t){let r=this.#a.get(t);return r===void 0&&(r=new t(this),this.#a.set(t,r)),r}validateSequenceCount(t){let r=Math.abs(t);if(r>this.#r)throw new RangeError(n.t("AppExtension.sequenceCountMustBeLessThanOrEqualTo",{sequenceCount:r,maximumSequenceCount:this.#r}))}};export{I as AlphabeticProxy,v as AlphanumericProxy,i as AppExtension,b as AppHelperProxy,y as CharacterSetCreatorProxy,d as CharacterSetValidatorProxy,C as HexadecimalProxy,T as LibProxy,E as Multiplicities,S as NumericProxy,x as RegExpProxy,h as TransformerProxy,u as Types,c as appExtensionNS,l as appExtensionResourceBundle,p as i18nAppExtensionInit,n as i18nextAppExtension};
 /*!
  * Copyright © 2024-2026 Dolphin Data Development Ltd. and AIDC Toolkit
  * contributors
@@ -14,10 +15,3 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from "./locale/i18n.js";
-export * from "./app-extension.js";
-export * from "./lib-proxy.js";
-export * from "./descriptor.js";
-export * from "./app-helper-proxy.js";
-export * from "./utility/index.js";
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aidc-toolkit/app-extension",
-  "version": "1.0.48-beta",
+  "version": "1.0.49",
   "description": "Application extension framework for AIDC Toolkit",
   "type": "module",
   "main": "dist/index.js",
@@ -34,11 +34,11 @@
     "generate-locale-resources": "tsx src/generator/locale-resources-generator.ts"
   },
   "devDependencies": {
-    "@aidc-toolkit/dev": "1.0.42-beta"
+    "@aidc-toolkit/dev": "^1.0.43"
   },
   "dependencies": {
-    "@aidc-toolkit/core": "1.0.43-beta",
-    "@aidc-toolkit/gs1": "1.0.45-beta",
-    "@aidc-toolkit/utility": "1.0.44-beta"
+    "@aidc-toolkit/core": "^1.0.44",
+    "@aidc-toolkit/gs1": "^1.0.46",
+    "@aidc-toolkit/utility": "^1.0.45"
   }
 }

package/src/app-extension.ts

@@ -8,6 +8,7 @@ import {
     type Promisable
 } from "@aidc-toolkit/core";
 import type { Logger } from "tslog";
+import type { LibProxy } from "./lib-proxy.js";
 import { i18nextAppExtension } from "./locale/i18n.js";
 import type { StreamingCancelledCallback, StreamingConsumerCallback } from "./streaming.js";
 import type { ErrorExtends, MatrixResult, SheetAddress, SheetRange, SingletonResult } from "./type.js";
@@ -76,6 +77,11 @@ export abstract class AppExtension<ThrowError extends boolean, TError extends Er
      */
     readonly #memoryTransport: MemoryTransport<object>;
 
+    /**
+     * Proxies map for lazy loading and memory management.
+     */
+    readonly #proxiesMap = new WeakMap<object, LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>>();
+
     /**
      * Constructor.
      *
@@ -155,6 +161,29 @@ export abstract class AppExtension<ThrowError extends boolean, TError extends Er
      */
     abstract get maximumHeight(): number;
 
+    /**
+     * Get a proxy instance. The use of a weak map ensures that proxies are loaded only as needed and may be garbage
+     * collected if required.
+     *
+     * @param ProxyConstructor
+     * Proxy constructor.
+     *
+     * @returns
+     * Proxy instance.
+     */
+    getProxy<T extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>>(ProxyConstructor: new (appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) => T): T {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type is managed in this method.
+        let proxy = this.#proxiesMap.get(ProxyConstructor) as T | undefined;
+
+        if (proxy === undefined) {
+            proxy = new ProxyConstructor(this);
+
+            this.#proxiesMap.set(ProxyConstructor, proxy);
+        }
+
+        return proxy;
+    }
+
     /**
      * Get the sheet address from an invocation context.
      *

package/src/app-helper-proxy.ts

@@ -31,6 +31,13 @@ const spillMaximumHeightParameterDescriptor: ExtendsParameterDescriptor = {
     name: "spillMaximumHeight"
 };
 
+const logLevelParameterDescriptor: ParameterDescriptor = {
+    name: "logLevel",
+    type: Types.String,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: false
+};
+
 /**
  * Maximum dimensions.
  */
@@ -257,6 +264,42 @@ export class AppHelperProxy<ThrowError extends boolean, TError extends ErrorExte
         return result;
     }
 
+    /**
+     * Get the logger messages. This is a snapshot, with the option to change the log level for the next call.
+     *
+     * @param logLevelString
+     * Log level as string.
+     *
+     * @returns
+     * Logger messages.
+     */
+    @proxy.describeMethod({
+        type: Types.String,
+        multiplicity: Multiplicities.Array,
+        isHidden: true,
+        parameterDescriptors: [logLevelParameterDescriptor]
+    })
+    loggerMessages(logLevelString: Nullishable<string>): MatrixResult<string, ThrowError, TError> {
+        const appExtension = this.appExtension;
+
+        let logLevel: LogLevel | undefined = undefined;
+
+        if (!isNullish(logLevelString)) {
+            try {
+                logLevel = logLevelOf(logLevelString);
+            } catch {
+                // Ignore error.
+            }
+        }
+
+        // Set log level if required.
+        if (logLevel !== undefined) {
+            appExtension.logger.settings.minLevel = logLevel;
+        }
+
+        return appExtension.memoryTransport.messages.map(message => [message]);
+    }
+
     /**
      * Get the logger messages as a stream.
      *
@@ -271,14 +314,9 @@ export class AppHelperProxy<ThrowError extends boolean, TError extends ErrorExte
         multiplicity: Multiplicities.Array,
         isHidden: true,
         isStream: true,
-        parameterDescriptors: [{
-            name: "logLevel",
-            type: Types.String,
-            multiplicity: Multiplicities.Singleton,
-            isRequired: false
-        }]
+        parameterDescriptors: [logLevelParameterDescriptor]
     })
-    loggerMessages(logLevelString: Nullishable<string>, streamingInvocationContext: Nullishable<TStreamingInvocationContext>): void {
+    loggerStream(logLevelString: Nullishable<string>, streamingInvocationContext: Nullishable<TStreamingInvocationContext>): void {
         if (isNullish(streamingInvocationContext)) {
             // Application error; no localization necessary.
             throw new Error("Streaming invocation context not provided by application");

package/src/generator/functions-generator.ts

@@ -0,0 +1,292 @@
+import {
+    type ClassDescriptor,
+    type MethodDescriptor,
+    type ParameterDescriptor,
+    type Type,
+    Types
+} from "../descriptor.js";
+import { type FunctionLocalization, Generator, type Localization } from "./generator.js";
+
+/**
+ * Class type alias.
+ */
+export interface ClassTypeAlias {
+    /**
+     * Name.
+     */
+    readonly name: string;
+
+    /**
+     * Getter function.
+     */
+    readonly getter: string;
+
+    /**
+     * Declaration associating name with implementation type and creating getter function.
+     */
+    readonly declaration: string[];
+}
+
+/**
+ * Function implementation.
+ */
+export interface FunctionImplementation {
+    /**
+     * Function name.
+     */
+    readonly functionName: string;
+
+    /**
+     * Parameter localizations with JavaScript type and parameter descriptor.
+     */
+    readonly parameterLocalizations: ReadonlyArray<Localization & {
+        /**
+         * JavaScript type.
+         */
+        javaScriptType: string;
+
+        /**
+         * Parameter descriptor.
+         */
+        parameterDescriptor?: ParameterDescriptor;
+    }>;
+
+    /**
+     * Declaration.
+     */
+    readonly declaration: string[];
+}
+
+/**
+ * Generator with helpers for writing TypeScript functions file.
+ */
+export abstract class FunctionsGenerator extends Generator {
+    /**
+     * Mapping of descriptor types to JavaScript types.
+     */
+    static readonly #DESCRIPTOR_TYPE_STRINGS: Readonly<Record<Type, string>> = {
+        [Types.String]: "string",
+        [Types.Number]: "number",
+        [Types.Boolean]: "boolean",
+        [Types.Any]: "any"
+    };
+
+    protected static readonly BASE_IMPORTS = [
+        "import * as AppExtension from \"@aidc-toolkit/app-extension\";",
+        "import { appExtension } from \"./app-extension.js\";"
+    ];
+
+    /**
+     * If true, functions are declared inline rather than using `function`.
+     */
+    readonly #inline: boolean;
+
+    /**
+     * If true, application extension supports context.
+     */
+    readonly #supportsContext: boolean;
+
+    /**
+     * Invocation context type name.
+     */
+    readonly #invocationContextTypeName: string;
+
+    /**
+     * Streaming invocation context type name.
+     */
+    readonly #streamingInvocationContextTypeName: string;
+
+    /**
+     * Template declaration for type alias.
+     */
+    readonly #templateDeclaration: string;
+
+    /**
+     * Current class type alias.
+     */
+    #classTypeAlias!: ClassTypeAlias;
+
+    /**
+     * Constructor.
+     *
+     * @param version
+     * Package version.
+     *
+     * @param inline
+     * If true, functions are declared inline rather than using `function`.
+     *
+     * @param throwError
+     * If true, errors are reported through the throw/catch mechanism.
+     *
+     * @param errorTypeName
+     * Error type name.
+     *
+     * @param supportsContext
+     * If true, application extension supports context.
+     *
+     * Big integer type name.
+     * @param invocationContextTypeName
+     * Invocation context type name.
+     *
+     * @param streamingInvocationContextTypeName
+     * Streaming invocation context type name.
+     *
+     * @param bigIntTypeName
+     * Big integer type name.
+     */
+    constructor(version: string, inline: boolean, throwError: boolean, errorTypeName: string, supportsContext: boolean, invocationContextTypeName: string, streamingInvocationContextTypeName: string, bigIntTypeName: string) {
+        super(version, true);
+
+        this.#inline = inline;
+
+        this.#supportsContext = supportsContext;
+        this.#invocationContextTypeName = invocationContextTypeName;
+        this.#streamingInvocationContextTypeName = streamingInvocationContextTypeName;
+
+        this.#templateDeclaration = `<${throwError}, ${errorTypeName}, ${invocationContextTypeName}, ${streamingInvocationContextTypeName}, ${bigIntTypeName}>`;
+    }
+
+    /**
+     * Get the class type alias.
+     */
+    get classTypeAlias(): ClassTypeAlias {
+        return this.#classTypeAlias;
+    }
+
+    /**
+     * Get the import statement for a namespace.
+     *
+     * @param namespace
+     * Namespace.
+     *
+     * @returns
+     * Import statement.
+     */
+    protected getNamespaceImport(namespace: string): string {
+        return `import * as AppExtension${namespace} from "@aidc-toolkit/app-extension/${namespace.toLowerCase()}";`;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected override createClassProxy(classDescriptor: ClassDescriptor): void {
+        const classDescriptorNamespace = classDescriptor.namespace ?? "";
+        const name = `${classDescriptorNamespace}${classDescriptor.name}`;
+        const getter = `get${name}()`;
+        const implementation = `AppExtension${classDescriptorNamespace}.${classDescriptor.name}${this.#templateDeclaration}`;
+
+        this.#classTypeAlias = {
+            name,
+            getter,
+            declaration: [
+                "",
+                "/**",
+                " * Class type alias name.",
+                " */",
+                `type ${name} = ${implementation};`,
+                "",
+                "/**",
+                " * Getter function to get an instance of the class.",
+                " *",
+                " * @returns",
+                " * Class instance.",
+                " */",
+                `function ${getter}: ${name} {`,
+                `    return appExtension.getProxy(${implementation});`,
+                "}"
+            ]
+        };
+    }
+
+    /**
+     * Get a function implementation.
+     *
+     * @param methodDescriptor
+     * Method descriptor.
+     *
+     * @param functionNamePrefix
+     * Function name prefix.
+     *
+     * @param functionLocalization
+     * Function localization. May be undefined for hidden functions, in which case generated
+     *
+     * @param parameterCallback
+     * Callback to modify parameter in implementation function call.
+     *
+     * @returns
+     * Function implementation.
+     */
+    protected getFunctionImplementation(methodDescriptor: MethodDescriptor, functionNamePrefix: string, functionLocalization: FunctionLocalization | undefined, parameterCallback?: (name: string, parameterDescriptor: ParameterDescriptor) => string): FunctionImplementation {
+        const methodType = `${this.classTypeAlias.name}["${methodDescriptor.name}"]`;
+
+        const parameterDescriptors = methodDescriptor.parameterDescriptors;
+
+        const parameterLocalizations: Array<FunctionImplementation["parameterLocalizations"][number]> = parameterDescriptors.map((parameterDescriptor) => {
+            const parameterLocalization = functionLocalization?.parametersMap.get(parameterDescriptor.name) ?? {
+                name: parameterDescriptor.name,
+                description: "*** NO LOCALIZATION ***"
+            };
+
+            return {
+                ...parameterLocalization,
+                javaScriptType: FunctionsGenerator.#DESCRIPTOR_TYPE_STRINGS[parameterDescriptor.type],
+                parameterDescriptor
+            };
+        });
+
+        const dummyParameters: string[] = [];
+
+        if (this.#supportsContext) {
+            if (methodDescriptor.requiresContext === true) {
+                parameterLocalizations.push({
+                    name: "invocationContext",
+                    description: "Invocation context.",
+                    javaScriptType: this.#invocationContextTypeName
+                });
+            }
+
+            if (methodDescriptor.isStream === true) {
+                parameterLocalizations.push({
+                    name: "streamingInvocationContext",
+                    description: "Streaming invocation context.",
+                    javaScriptType: this.#streamingInvocationContextTypeName
+                });
+            }
+        } else {
+            if (methodDescriptor.requiresContext === true) {
+                // Invocation context type name represents a literal dummy value.
+                dummyParameters.push(this.#invocationContextTypeName);
+            }
+
+            if (methodDescriptor.isStream === true) {
+                // Streaming invocation context type name represents a literal dummy value.
+                dummyParameters.push(this.#streamingInvocationContextTypeName);
+            }
+        }
+
+        const asyncQualifier = methodDescriptor.isAsync === true ? "async " : "";
+        const functionName = functionNamePrefix === "" ?
+            functionLocalization?.name ?? methodDescriptor.name :
+            `${functionNamePrefix}${functionLocalization?.titleCaseName ?? methodDescriptor.name.replace(/^[a-z]/u, c => c.toUpperCase())}`;
+
+        return {
+            functionName,
+            parameterLocalizations,
+            declaration: [
+                `${
+                    !this.#inline ?
+                        `export ${asyncQualifier}function ${functionName}` :
+                        asyncQualifier
+                }(${parameterLocalizations.map((parameterLocalization, index) =>
+                    `${parameterLocalization.name}: Parameters<${methodType}>[${index}]`
+                ).join(", ")}): ReturnType<${methodType}> ${!this.#inline ? "{" : "=>"}`,
+                `    ${!this.#inline ? "return " : ""}${(this.classTypeAlias.getter)}.${methodDescriptor.name}(${[...parameterLocalizations.map(parameterLocalization =>
+                    parameterCallback === undefined || parameterLocalization.parameterDescriptor === undefined ?
+                        parameterLocalization.name :
+                        parameterCallback(parameterLocalization.name, parameterLocalization.parameterDescriptor)
+                ), ...dummyParameters].join(", ")})${(!this.#inline ? ";" : "")}`,
+                ...!this.#inline ? ["}"] : []
+            ]
+        };
+    }
+}

package/src/generator/generator.ts

@@ -1,4 +1,4 @@
-import { ALPHA_URL, getLogger, I18nEnvironments, type Promisable, websiteURL } from "@aidc-toolkit/core";
+import { ALPHA_URL, getLogger, I18nLanguageDetectors, type Promisable, websiteURL } from "@aidc-toolkit/core";
 import type { DefaultNamespace, ParseKeys } from "i18next";
 import type { Logger } from "tslog";
 import { AppHelperProxy } from "../app-helper-proxy.js";
@@ -155,18 +155,15 @@ export abstract class Generator {
     protected abstract createCategory(namespace: string | undefined, category: string, categoryLocalizationsMap: ReadonlyMap<string, string>): void;
 
     /**
-     * Create a proxy object for a class.
-     *
-     * @param objectName
-     * Object name, derived from namespace and class name.
+     * Create a proxy for a class.
      *
      * @param classDescriptor
      * Class descriptor.
      */
-    protected abstract createProxyObject(objectName: string, classDescriptor: ClassDescriptor): void;
+    protected abstract createClassProxy(classDescriptor: ClassDescriptor): void;
 
     /**
-     * Create a proxy function for a class and method.
+     * Create a proxy for a method.
      *
      * @param classDescriptor
      * Class descriptor.
@@ -177,7 +174,7 @@ export abstract class Generator {
      * @param functionLocalizationsMap
      * Function localizations map.
      */
-    protected abstract createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
+    protected abstract createMethodProxy(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
 
     /**
      * Finalize the generation of the output.
@@ -228,7 +225,7 @@ export abstract class Generator {
     async generate(): Promise<void> {
         let success = false;
 
-        await i18nAppExtensionInit(I18nEnvironments.CLI);
+        await i18nAppExtensionInit(I18nLanguageDetectors.CLI);
 
         const documentationBaseURL = websiteURL(this.version, true, await ALPHA_URL);
 
@@ -293,31 +290,14 @@ export abstract class Generator {
 
                         namespaceClassNamesSet.add(namespaceClassName);
 
-                        // 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 objectNameGroups = /^(?<namespaceFirstWord>[A-Z]+[0-9]*|[A-Z][^A-Z.]*)(?<namespaceRemaining>[A-Z][^.]*|)\.?(?<className>[A-Z].*|)$/u.exec(namespaceClassName)?.groups;
-
-                        if (objectNameGroups === undefined) {
-                            throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
-                        }
-
-                        this.createProxyObject(`${objectNameGroups["namespaceFirstWord"].toLowerCase()}${objectNameGroups["namespaceRemaining"]}${objectNameGroups["className"]}`, classDescriptor);
+                        this.createClassProxy(classDescriptor);
 
                         for (const methodDescriptor of classDescriptor.methodDescriptors) {
                             const functionLocalizationsMap = new Map(methodDescriptor.isHidden !== true ?
                                 this.locales.map(locale =>
                                     [locale, Generator.#generateLocalization<FunctionLocalization>(locale, `Functions.${namespacePrefix}${methodDescriptor.functionName}`, (locale, localization) => ({
                                         ...localization,
-                                        titleCaseName: localization.titleCaseName ?? `${localization.name.substring(0, 1).toUpperCase()}${localization.name.substring(1)}`,
+                                        titleCaseName: localization.titleCaseName ?? localization.name.replace(/^[a-z]/u, c => c.toUpperCase()),
                                         documentationURL: `${documentationBaseURL}/${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.
@@ -329,7 +309,7 @@ export abstract class Generator {
                                 []
                             );
 
-                            this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
+                            this.createMethodProxy(classDescriptor, methodDescriptor, functionLocalizationsMap);
                         }
                     }
                 }

package/src/generator/index.ts

@@ -16,3 +16,4 @@
  */
 
 export * from "./generator.js";
+export * from "./functions-generator.js";

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

@@ -1,13 +1,13 @@
 import type { LocaleResources } from "@aidc-toolkit/core";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import packageConfiguration from "../../package.json" with { type: "json" };
 import type {
     ClassDescriptor,
     ExtendsParameterDescriptor,
     MethodDescriptor,
     ParameterDescriptor
 } from "../descriptor.js";
+import { VERSION } from "../version.js";
 import { Generator } from "./generator.js";
 
 /**
@@ -91,7 +91,7 @@ class LocaleResourcesGenerator extends Generator {
      * Constructor.
      */
     constructor() {
-        super(packageConfiguration.version, false);
+        super(VERSION, false);
     }
 
     /**
@@ -115,7 +115,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected override createProxyObject(): void {
+    protected override createClassProxy(): void {
     }
 
     /**
@@ -193,7 +193,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected override createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
+    protected override createMethodProxy(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
         // Hidden functions aren't localized.
         if (methodDescriptor.isHidden !== true) {
             // Add any parameters that are not already known.
@@ -255,15 +255,17 @@ class LocaleResourcesGenerator extends Generator {
      * Merged locale resources.
      */
     #merge(logChanges: boolean, parentKey: string, sourceLocaleResources: LocaleResources, destinationLocaleResources: LocaleResources, addMissing: boolean): LocaleResources {
-        // Some entries at the top are not part of the generator output.
-        const deleteMissing = parentKey.length !== 0;
+        // Some entries at the root are not part of the generator output.
+        const atRoot = parentKey === "";
+
+        const atFunction = parentKey.startsWith("Functions.");
 
         const newDestinationLocaleResources: LocaleResources = {};
 
         // Copy over or delete any destination keys that are not in source.
         for (const [key, destinationValue] of Object.entries(destinationLocaleResources)) {
             if (!(key in sourceLocaleResources)) {
-                if (!deleteMissing) {
+                if (atRoot || (atFunction && key === "titleCaseName")) {
                     newDestinationLocaleResources[key] = destinationValue;
                 } else if (logChanges) {
                     this.logger.info(`Deleting ${parentKey}${key}...`);

package/src/gs1/check-proxy.ts

@@ -67,7 +67,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [numericSWithCheckDigitParameterDescriptor]
     })
@@ -85,7 +85,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Singleton,
         parameterDescriptors: [{
             ...numericSFourOrFiveDigitsParameterDescriptor,
@@ -106,7 +106,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [ai82SWithCheckCharacterPairParameterDescriptor]
     })

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

@@ -128,7 +128,7 @@ export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
     })
@@ -148,7 +148,7 @@ export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTIN14ParameterDescriptor]
     })

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

@@ -61,7 +61,7 @@ abstract class NumericIdentifierValidatorProxy<ThrowError extends boolean, TErro
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateIdentifierParameterDescriptor]
     })
@@ -109,7 +109,7 @@ export abstract class NonNumericIdentifierValidatorProxy<ThrowError extends bool
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateIdentifierParameterDescriptor, exclusionAllNumericParameterDescriptor]
     })