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

package/src/descriptor.ts

@@ -43,6 +43,42 @@ export type TypeKey = keyof typeof Types;
  */
 export type Type = typeof Types[TypeKey];
 
+/**
+ * Multiplicities supported by proxy methods.
+ */
+export const Multiplicities = {
+    /**
+     * Parameter or return value is a singleton.
+     */
+    Singleton: 0,
+
+    /**
+     * Parameter or return value is a singleton or an array.
+     */
+    Array: 1,
+
+    /**
+     * Parameter or return value is a singleton, an array, or a matrix.
+     */
+    Matrix: 2,
+
+    /**
+     * Parameter value is a singleton or array but is treated as a singleton internally and doesn't drive multiplicity
+     * of the return value. Return value is an array for use as a singleton array parameter.
+     */
+    SingletonArray: 3
+} as const;
+
+/**
+ * Multiplicity key.
+ */
+export type MultiplicityKey = keyof typeof Multiplicities;
+
+/**
+ * Multiplicity.
+ */
+export type Multiplicity = typeof Multiplicities[MultiplicityKey];
+
 /**
  * Type descriptor.
  */
@@ -53,9 +89,9 @@ interface TypeDescriptor extends Descriptor {
     readonly type: Type;
 
     /**
-     * True if type is a matrix (method accepts or returns a two-dimensional array).
+     * Multiplicity.
      */
-    readonly isMatrix: boolean;
+    readonly multiplicity: Multiplicity;
 }
 
 /**
@@ -83,6 +119,21 @@ export interface ExtendsParameterDescriptor extends Partial<ParameterDescriptor>
     readonly sortOrder?: number;
 }
 
+/**
+ * Replacement parameter descriptor.
+ */
+export interface ReplacementParameterDescriptor {
+    /**
+     * Name to replace.
+     */
+    readonly name: string;
+
+    /**
+     * Replacement parameter descriptor.
+     */
+    readonly replacement: ParameterDescriptor;
+}
+
 /**
  * Method descriptor.
  */
@@ -92,6 +143,21 @@ export interface MethodDescriptor extends TypeDescriptor {
      */
     readonly requiresContext?: boolean;
 
+    /**
+     * If true, function is hidden from user interface.
+     */
+    readonly isHidden?: boolean;
+
+    /**
+     * If true, function is volatile and should be reevaluated regularly.
+     */
+    readonly isVolatile?: boolean;
+
+    /**
+     * If true, function opens a stream that updates asynchronously.
+     */
+    readonly isStream?: boolean;
+
     /**
      * If true, method infix is ignored.
      */
@@ -128,18 +194,20 @@ export interface ClassDescriptor extends Descriptor {
      */
     readonly namespace?: string | undefined;
 
+    /**
+     * Category.
+     */
+    readonly category: string;
+
     /**
      * Method infix. If undefined, method name is generated verbatim.
      */
     readonly methodInfix?: string | undefined;
 
     /**
-     * Replace parameter descriptors for class hierarchies where enumeration parameter descriptors can change.
+     * Replacement parameter descriptors  for class hierarchies where parameter types can narrow
      */
-    readonly replaceParameterDescriptors?: ReadonlyArray<{
-        readonly name: string;
-        readonly replacement: ParameterDescriptor;
-    }>;
+    readonly replacementParameterDescriptors?: ReplacementParameterDescriptor[];
 
     /**
      * Class name in optional namespace.

package/src/generator/generator.ts

@@ -1,9 +1,10 @@
-import { I18nEnvironments } from "@aidc-toolkit/core";
-import type { ParseKeys } from "i18next";
-import { AppUtilityProxy } from "../app-utility-proxy.js";
+import { getLogger, I18nEnvironments, type Promisable } from "@aidc-toolkit/core";
+import type { DefaultNamespace, ParseKeys } from "i18next";
+import type { Logger } from "tslog";
+import { AppHelperProxy } from "../app-helper-proxy.js";
 import type { ClassDescriptor, MethodDescriptor } from "../descriptor.js";
 import * as GS1 from "../gs1/index.js";
-import { appExtensionResources, i18nAppExtensionInit, i18nextAppExtension } from "../locale/i18n.js";
+import { appExtensionResourceBundle, i18nAppExtensionInit, i18nextAppExtension } from "../locale/i18n.js";
 import { proxy } from "../proxy.js";
 import * as Utility from "../utility/index.js";
 
@@ -16,7 +17,8 @@ import * as Utility from "../utility/index.js";
 function registerProxies(..._proxies: unknown[]): void {
 }
 
-registerProxies(AppUtilityProxy, Utility, GS1);
+registerProxies(AppHelperProxy, Utility, GS1);
+
 /**
  * Localization.
  */
@@ -24,27 +26,32 @@ export interface Localization {
     /**
      * Name.
      */
-    name: string;
+    readonly name: string;
 
     /**
      * Description.
      */
-    description: string;
+    readonly description: string;
 }
 
 /**
  * Function localization.
  */
 export interface FunctionLocalization extends Localization {
+    /**
+     * Namespace function name.
+     */
+    readonly namespaceFunctionName: string;
+
     /**
      * Documentation URL.
      */
-    documentationURL: string;
+    readonly documentationURL: string;
 
     /**
      * Parameters map.
      */
-    parametersMap: Map<string, Localization>;
+    readonly parametersMap: ReadonlyMap<string, Localization>;
 }
 
 /**
@@ -61,6 +68,11 @@ export abstract class Generator {
      */
     static readonly #DOCUMENTATION_PATH = "app-extension/";
 
+    /**
+     * Logger.
+     */
+    readonly #logger = getLogger();
+
     /**
      * Locales.
      */
@@ -71,11 +83,6 @@ export abstract class Generator {
      */
     readonly #defaultLocale: string;
 
-    /**
-     * Map of function localizations maps by namespace function name.
-     */
-    readonly #functionLocalizationsMapsMap = new Map<string, ReadonlyMap<string, FunctionLocalization>>();
-
     /**
      * Constructor.
      *
@@ -83,10 +90,17 @@ export abstract class Generator {
      * Include localizations if true.
      */
     constructor(includeLocalizations = true) {
-        this.#locales = includeLocalizations ? Object.keys(appExtensionResources) : [];
+        this.#locales = includeLocalizations ? Object.keys(appExtensionResourceBundle) : [];
         this.#defaultLocale = this.#locales[0] ?? "";
     }
 
+    /**
+     * Get the logger.
+     */
+    get logger(): Logger<object> {
+        return this.#logger;
+    }
+
     /**
      * Get the locales.
      */
@@ -102,56 +116,31 @@ export abstract class Generator {
     }
 
     /**
-     * Get function localization.
-     *
-     * @param locale
-     * Locale.
-     *
-     * @param namespaceFunctionName
-     * Namespace function name.
-     *
-     * @returns
-     * Function localization.
+     * Initialize the generation of the output.
      */
-    protected getFunctionLocalization(locale: string, namespaceFunctionName: string): FunctionLocalization {
-        const functionLocalization = this.#functionLocalizationsMapsMap.get(namespaceFunctionName)?.get(locale);
-
-        if (functionLocalization === undefined) {
-            throw new Error(`${locale} localization for function ${namespaceFunctionName} not found`);
-        }
-
-        return functionLocalization;
-    }
+    protected abstract initialize(): void;
 
     /**
-     * Get parameter localization.
-     *
-     * @param locale
-     * Locale.
+     * Create a namespace.
      *
-     * @param namespaceFunctionName
-     * Namespace function name.
-     *
-     * @param parameterName
-     * Parameter name.
-     *
-     * @returns
-     * Parameter localization.
+     * @param namespace
+     * Namespace.
      */
-    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`);
-        }
-
-        return parameterLocalization;
-    }
+    protected abstract createNamespace(namespace: string | undefined): void;
 
     /**
-     * Initialize the generation of the output.
+     * Create a category.
+     *
+     * @param namespace
+     * Namespace.
+     *
+     * @param category
+     * Category.
+     *
+     * @param categoryLocalizationsMap
+     * Category localizations map.
      */
-    protected abstract initialize(): void;
+    protected abstract createCategory(namespace: string | undefined, category: string, categoryLocalizationsMap: ReadonlyMap<string, string>): void;
 
     /**
      * Create a proxy object for a class.
@@ -171,7 +160,7 @@ export abstract class Generator {
      * Method descriptor.
      *
      * @param functionLocalizationsMap
-     * Localizations map.
+     * Function localizations map.
      */
     protected abstract createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
 
@@ -181,7 +170,7 @@ export abstract class Generator {
      * @param success
      * True if successful.
      */
-    protected abstract finalize(success: boolean): void | Promise<void>;
+    protected abstract finalize(success: boolean): Promisable<void>;
 
     /**
      * Generate a localization.
@@ -192,11 +181,8 @@ export abstract class Generator {
      * @param locale
      * Locale.
      *
-     * @param localizedKeyPrefix
-     * Localized key prefix.
-     *
-     * @param namespacePrefix
-     * Namespace prefix to be appended to name.
+     * @param key
+     * Key.
      *
      * @param localizationCallback
      * Callback to finalize localization.
@@ -204,17 +190,14 @@ export abstract class Generator {
      * @returns
      * Localization.
      */
-    #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)
-        });
+    static #generateLocalization<TLocalization extends Localization>(locale: string, key: string, localizationCallback: (locale: string, localization: Localization) => TLocalization): TLocalization {
+        const lngReturnObjectsOption = {
+            lng: locale,
+            returnObjects: true
+        } as const;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists and return type is Localization.
+        return localizationCallback(locale, i18nextAppExtension.t(key as ParseKeys<DefaultNamespace, typeof lngReturnObjectsOption>, lngReturnObjectsOption) as Localization);
     }
 
     /**
@@ -225,36 +208,75 @@ export abstract class Generator {
 
         await i18nAppExtensionInit(I18nEnvironments.CLI);
 
-        // const LocaleResourcesSource = path.resolve(LocaleResourcesGenerator.IMPORT_PATH, entry.name, "locale-resources.ts");
-        //
-        // await import(LocaleResourcesSource).then((module) => {
-
         this.initialize();
 
+        const namespaceHierarchy = new Map<string | undefined, Map<string, ClassDescriptor[]>>();
+
+        // Organize class descriptors by namespace and category.
+        for (const classDescriptor of proxy.classDescriptors) {
+            const namespace = classDescriptor.namespace;
+            const category = classDescriptor.category;
+
+            let categoryHierarchy = namespaceHierarchy.get(namespace);
+
+            if (categoryHierarchy === undefined) {
+                categoryHierarchy = new Map();
+                namespaceHierarchy.set(namespace, categoryHierarchy);
+            }
+
+            let classDescriptors = categoryHierarchy.get(category);
+
+            if (classDescriptors === undefined) {
+                classDescriptors = [];
+                categoryHierarchy.set(category, classDescriptors);
+            }
+
+            classDescriptors.push(classDescriptor);
+        }
+
         try {
-            for (const [_namespaceClassName, classDescriptor] of proxy.classDescriptorsMap.entries()) {
-                const namespace = classDescriptor.namespace;
+            for (const [namespace, categoryHierarchy] of namespaceHierarchy) {
                 const namespacePrefix = namespace === undefined ? "" : `${namespace}.`;
                 const namespacePath = namespace === undefined ? "" : `${namespace}/`;
 
-                this.createProxyObject(classDescriptor);
+                this.createNamespace(namespace);
+
+                for (const [category, classDescriptors] of categoryHierarchy) {
+                    const namespaceCategory = `${namespacePrefix}${category}`;
+
+                    const categoriesKey = `Categories.${category}`;
+                    const namespaceCategoriesKey = `Categories.${namespaceCategory}`;
+
+                    const categoryLocalizationsMap = new Map(this.locales.map((locale) => {
+                        const lngOption = {
+                            lng: locale
+                        } as const;
+
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
+                        return [locale, i18nextAppExtension.t((i18nextAppExtension.exists(namespaceCategoriesKey, lngOption) ? namespaceCategoriesKey : categoriesKey) as ParseKeys, lngOption)];
+                    }));
+
+                    this.createCategory(namespace, category, categoryLocalizationsMap);
 
-                for (const methodDescriptor of classDescriptor.methodDescriptors) {
-                    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)]
-                            ))
-                        }))]
-                    ));
+                    for (const classDescriptor of classDescriptors) {
+                        this.createProxyObject(classDescriptor);
 
-                    this.#functionLocalizationsMapsMap.set(namespaceFunctionName, functionLocalizationsMap);
+                        for (const methodDescriptor of classDescriptor.methodDescriptors) {
+                            const functionLocalizationsMap = new Map(this.locales.map(locale =>
+                                [locale, Generator.#generateLocalization<FunctionLocalization>(locale, `Functions.${methodDescriptor.namespaceFunctionName}`, (locale, localization) => ({
+                                    ...localization,
+                                    namespaceFunctionName: `${namespacePrefix}${localization.name}`,
+                                    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, Generator.#generateLocalization(locale, `Parameters.${parameterDescriptor.name}`, (_locale, localization) => localization)]
+                                    ))
+                                }))]
+                            ));
 
-                    this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
+                            this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
+                        }
+                    }
                 }
             }
 

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

@@ -1,4 +1,4 @@
-import { getLogger, type LocaleResources } from "@aidc-toolkit/core";
+import type { LocaleResources } from "@aidc-toolkit/core";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
@@ -14,7 +14,7 @@ import { Generator } from "./generator.js";
  */
 interface ParametersSequencerEntry {
     /**
-     * Parameters sequence or null if automatic.
+     * Parameters sequencer or null if automatic.
      */
     parametersSequencerOrNull: ParametersSequencer | null;
 
@@ -42,7 +42,6 @@ interface ParametersSequencerEntry {
 /**
  * Parameters sequencer for keeping similar (extended) parameters together.
  */
-// TODO Replace with map.
 type ParametersSequencer = Record<string, ParametersSequencerEntry>;
 
 /**
@@ -64,11 +63,6 @@ class LocaleResourcesGenerator extends Generator {
      */
     static readonly #IMPORT_PATH = "../app-extension/src/locale";
 
-    /**
-     * Logger.
-     */
-    readonly #logger = getLogger();
-
     /**
      * Parameters sequencer.
      */
@@ -102,13 +96,25 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected initialize(): void {
+    protected override initialize(): void {
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected override createNamespace(): void {
     }
 
     /**
      * @inheritDoc
      */
-    protected createProxyObject(): void {
+    protected override createCategory(): void {
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected override createProxyObject(): void {
     }
 
     /**
@@ -186,41 +192,44 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    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);
-        }
+    protected override createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
+        // Hidden functions aren't localized.
+        if (!(methodDescriptor.isHidden ?? false)) {
+            // Add any parameters that are not already known.
+            for (const parameterDescriptor of methodDescriptor.parameterDescriptors) {
+                this.#saveParameterSequence(parameterDescriptor, true);
+            }
 
-        let functionsLocaleResources = this.#functionsLocaleResources;
+            let functionsLocaleResources = this.#functionsLocaleResources;
 
-        const namespace = classDescriptor.namespace;
+            const namespace = classDescriptor.namespace;
 
-        if (namespace !== undefined) {
-            if (!(namespace in functionsLocaleResources)) {
-                const namespaceFunctionsLocaleResources: LocaleResources = {};
+            if (namespace !== undefined) {
+                if (!(namespace in functionsLocaleResources)) {
+                    const namespaceFunctionsLocaleResources: LocaleResources = {};
 
-                // Add namespace and navigate to it.
-                functionsLocaleResources[namespace] = namespaceFunctionsLocaleResources;
-                functionsLocaleResources = namespaceFunctionsLocaleResources;
-            } else {
-                // Navigate to namespace.
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Entry is never a string.
-                functionsLocaleResources = functionsLocaleResources[namespace] as LocaleResources;
+                    // Add namespace and navigate to it.
+                    functionsLocaleResources[namespace] = namespaceFunctionsLocaleResources;
+                    functionsLocaleResources = namespaceFunctionsLocaleResources;
+                } else {
+                    // Navigate to namespace.
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Entry is never a string.
+                    functionsLocaleResources = functionsLocaleResources[namespace] as LocaleResources;
+                }
             }
-        }
 
-        const functionName = methodDescriptor.functionName;
+            const functionName = methodDescriptor.functionName;
 
-        if (functionName in functionsLocaleResources) {
-            throw new Error(`Duplicate function ${functionName}`);
-        }
+            if (functionName in functionsLocaleResources) {
+                throw new Error(`Duplicate function ${functionName}`);
+            }
 
-        // Add function.
-        functionsLocaleResources[functionName] = {
-            name: functionName,
-            description: "*** LOCALIZATION REQUIRED ***"
-        };
+            // Add function.
+            functionsLocaleResources[functionName] = {
+                name: functionName,
+                description: "*** LOCALIZATION REQUIRED ***"
+            };
+        }
     }
 
     /**
@@ -256,7 +265,7 @@ class LocaleResourcesGenerator extends Generator {
                 if (!deleteMissing) {
                     newDestinationLocaleResources[key] = destinationValue;
                 } else if (logChanges) {
-                    this.#logger.info(`Deleting ${parentKey}${key}...`);
+                    this.logger.info(`Deleting ${parentKey}${key}...`);
                 }
             }
         }
@@ -265,7 +274,7 @@ class LocaleResourcesGenerator extends Generator {
             if (!(key in destinationLocaleResources)) {
                 if (addMissing) {
                     if (logChanges) {
-                        this.#logger.info(`Adding ${parentKey}${key}...`);
+                        this.logger.info(`Adding ${parentKey}${key}...`);
                     }
 
                     newDestinationLocaleResources[key] = sourceValue;
@@ -364,7 +373,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected async finalize(success: boolean): Promise<void> {
+    protected override async finalize(success: boolean): Promise<void> {
         if (success) {
             this.#buildParametersLocaleResources(this.#parametersSequencer);
 
@@ -373,7 +382,7 @@ class LocaleResourcesGenerator extends Generator {
             }).filter(entry => entry.isDirectory()).map(async (entry) => {
                 const localeResourcesSource = path.resolve(LocaleResourcesGenerator.#IMPORT_PATH, entry.name, "locale-resources.ts");
 
-                await import(localeResourcesSource).then((module) => {
+                return import(localeResourcesSource).then((module) => {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Module format is known.
                     const localeResources = this.#merge(entry.name === "en", "", this.#LocaleResources, (module as LocaleResourcesModule).default, !entry.name.includes("-"));
 
@@ -384,4 +393,9 @@ class LocaleResourcesGenerator extends Generator {
     }
 }
 
-await new LocaleResourcesGenerator().generate();
+const generator = new LocaleResourcesGenerator();
+
+generator.generate().catch((e: unknown) => {
+    generator.logger.error(e);
+    process.exit(1);
+});

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

@@ -11,15 +11,15 @@ import { CharacterSetCreatorProxy, CharacterSetValidatorProxy } from "../utility
 @proxy.describeClass(false, {
     namespace: "GS1",
     methodInfix: "AI82",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
             replacement: exclusionAllNumericParameterDescriptor
         }
     ]
 })
-export class AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, AI82_CREATOR);
     }
 }
@@ -27,15 +27,15 @@ export class AI82Proxy<ThrowError extends boolean, TError extends ErrorExtends<T
 @proxy.describeClass(false, {
     namespace: "GS1",
     methodInfix: "AI39",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
             replacement: exclusionAllNumericParameterDescriptor
         }
     ]
 })
-export class AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, AI39_CREATOR);
     }
 }
@@ -44,8 +44,8 @@ export class AI39Proxy<ThrowError extends boolean, TError extends ErrorExtends<T
     namespace: "GS1",
     methodInfix: "AI64"
 })
-export class AI64Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class AI64Proxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetValidatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, AI64_VALIDATOR);
     }
 }