@aidc-toolkit/app-extension 1.0.28-beta → 1.0.32-beta

package/src/app-utility-proxy.ts

@@ -1,11 +1,11 @@
-import { isNullish, type NonNullishable, type Nullishable } from "@aidc-toolkit/core";
+import { isNullish, type LogLevel, logLevelOf, type NonNullishable, type Nullishable } from "@aidc-toolkit/core";
 import { type ExtendsParameterDescriptor, 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 } from "./type.js";
+import type { ErrorExtends, Matrix, MatrixResult } from "./type.js";
 
-const spillMatrix: ParameterDescriptor = {
+const spillMatrixParameterDescriptor: ParameterDescriptor = {
     name: "spillMatrix",
     type: Types.Any,
     isMatrix: true,
@@ -49,7 +49,7 @@ interface MaximumDimensions {
 /**
  * Application utilities.
  *
- *@template ThrowError
+ * @template ThrowError
  * If true, errors are reported through the throw/catch mechanism.
  *
  * @template TError
@@ -58,11 +58,14 @@ interface MaximumDimensions {
  * @template TInvocationContext
  * Application-specific invocation context type.
  *
+ * @template TStreamingInvocationContext
+ * Application-specific streaming invocation context type.
+ * 
  * @template TBigInt
  * Type to which big integer is mapped.
  */
 @proxy.describeClass(false)
-export class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     /**
      * Get the version.
      *
@@ -106,8 +109,8 @@ export class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExt
         if (isNullish(maximumWidth) || isNullish(maximumHeight)) {
             const sheetAddress = await this.appExtension.getSheetAddress(invocationContext);
 
-            definedMaximumWidth = maximumWidth ?? await this.appExtension.maximumWidth() - sheetAddress.columnIndex;
-            definedMaximumHeight = maximumHeight ?? await this.appExtension.maximumHeight() - sheetAddress.rowIndex;
+            definedMaximumWidth = maximumWidth ?? this.appExtension.maximumWidth - sheetAddress.columnIndex;
+            definedMaximumHeight = maximumHeight ?? this.appExtension.maximumHeight - sheetAddress.rowIndex;
         } else {
             definedMaximumWidth = maximumWidth;
             definedMaximumHeight = maximumHeight;
@@ -120,154 +123,202 @@ export class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExt
     }
 
     /**
-     * Spill a horizontal matrix vertically to fit within a maximum width and height.
+     * Spill a one-dimensional matrix to fit a rectangle within a given maximum height and width.
      *
-     * @param hMatrixValues
-     * Horizontal matrix values. Matrix has length 1 and contains a single array with the values.
-     *
-     * @param maximumWidth
-     * Maximum width.
+     * @param matrixValues
+     * Matrix values. Matrix is length 1 or contains arrays of length 1 with the values.
      *
      * @param maximumHeight
      * Maximum height.
      *
+     * @param maximumWidth
+     * Maximum width.
+     *
      * @param invocationContext
      * Invocation context.
      *
      * @returns
-     * Matrix spilled within maximum width and maximum height.
+     * Matrix spilled within maximum height and maximum width.
      */
     @proxy.describeMethod({
         requiresContext: true,
         type: Types.Any,
         isMatrix: true,
-        parameterDescriptors: [spillMatrix, spillMaximumWidthParameterDescriptor, spillMaximumHeightParameterDescriptor]
+        parameterDescriptors: [spillMatrixParameterDescriptor, spillMaximumHeightParameterDescriptor, spillMaximumWidthParameterDescriptor]
     })
-    async vSpill(hMatrixValues: Matrix<unknown>, maximumWidth: Nullishable<number>, maximumHeight: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>> {
-        let result: Matrix<unknown>;
+    async spill(matrixValues: Matrix<unknown>, maximumHeight: Nullishable<number>, maximumWidth: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<MatrixResult<unknown, ThrowError, TError>> {
+        let result: MatrixResult<unknown, ThrowError, TError>;
 
-        if (hMatrixValues.length !== 1) {
-            throw new RangeError(i18nextAppExtension.t("Proxy.vSpillMustBeHorizontalArray"));
-        }
+        // Assume matrix is uniformly two-dimensional.
+        const height = matrixValues.length;
+        const width = height !== 0 ? matrixValues[0].length : 0;
 
-        const maximumDimensions = await this.#defaultMaximums({
-            width: maximumWidth,
-            height: maximumHeight
-        }, invocationContext);
+        const isArrayOrError = this.singletonResult(() => {
+            if (height > 1 && width > 1) {
+                throw new RangeError(i18nextAppExtension.t("Proxy.matrixMustBeArray"));
+            }
 
-        const hArrayValues = hMatrixValues[0];
-        const hLength = hArrayValues.length;
-        const maximumArea = maximumDimensions.width * maximumDimensions.height;
+            return true;
+        });
+
+        if (isArrayOrError === true) {
+            const maximumDimensions = await this.#defaultMaximums({
+                width: maximumWidth,
+                height: maximumHeight
+            }, invocationContext);
+
+            const isHorizontal = height === 1;
+            const length = isHorizontal ? width : height;
+            const maximumParallel = isHorizontal ? maximumDimensions.width : maximumDimensions.height;
+            const maximumPerpendicular = isHorizontal ? maximumDimensions.height : maximumDimensions.width;
+            const maximumArea = maximumParallel * maximumPerpendicular;
+
+            // Lengths 0 and 1 are valid and require no special processing.
+            if (length > 1 && length <= maximumArea) {
+                const lengthSquareRoot = Math.sqrt(length);
+
+                let spillParallel: number | undefined = undefined;
+
+                // Array that has a length of a power of 10 is treated specially.
+                if (Number.isInteger(Math.log10(length))) {
+                    // Try spill that is a power of 10, favouring the parallel direction.
+                    let spillParallel10 = 10 ** Math.ceil(Math.log10(lengthSquareRoot));
+
+                    // Favour the perpendicular direction if not enough parallel space.
+                    if (spillParallel10 > maximumParallel) {
+                        spillParallel10 /= 10;
+                    }
+
+                    // Take result as the spill parallel if it fits.
+                    if (spillParallel10 <= maximumParallel && length / spillParallel10 <= maximumPerpendicular) {
+                        spillParallel = spillParallel10;
+                    }
+                }
 
-        // Lengths 0 and 1 are valid and require no special processing.
-        if (hLength > 1 && hLength <= maximumArea) {
-            // Make spill as square as possible.
-            let spillWidth = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.width);
+                // Make spill as square as possible, favouring the parallel direction.
+                spillParallel ??= Math.max(Math.min(Math.ceil(lengthSquareRoot), maximumParallel), Math.floor(length / maximumPerpendicular));
 
-            // Array that has a length of a power of 10 is treated specially.
-            if (Number.isInteger(Math.log10(hLength))) {
-                // Try spill width that is a power of 10.
-                const spillWidth10 = 10 ** Math.floor(Math.log10(spillWidth));
+                const spillPerpendicular = Math.ceil(length / spillParallel);
 
-                // Keep default if not enough space for power of 10 matrix.
-                if (hLength / spillWidth10 <= maximumDimensions.height) {
-                    spillWidth = spillWidth10;
-                }
-            }
+                result = [];
+
+                if (isHorizontal) {
+                    let startIndex = 0;
+
+                    do {
+                        const endIndex = startIndex + spillParallel;
+
+                        // Each row is a slice of the original single row.
+                        const row = matrixValues[0].slice(startIndex, endIndex);
+
+                        // Row length will be anywhere from 1 to spillParallel.
+                        if (row.length < spillParallel) {
+                            const rowLength = row.length;
+
+                            row.length = spillParallel;
 
-            result = [];
+                            // Fill empty cells with empty string.
+                            row.fill("", rowLength, spillParallel);
+                        }
 
-            let hStartIndex = 0;
+                        result.push(row);
 
-            do {
-                const hEndIndex = hStartIndex + spillWidth;
+                        startIndex = endIndex;
+                    } while (startIndex < length);
+                } else {
+                    for (let rowIndex = 0; rowIndex < spillParallel; rowIndex++) {
+                        const row: unknown[] = [];
 
-                result.push(hArrayValues.slice(hStartIndex, hEndIndex));
+                        // Each column is a slice of the original single column.
+                        for (let valueIndex = rowIndex; valueIndex < length; valueIndex += spillParallel) {
+                            row.push(matrixValues[valueIndex][0]);
+                        }
 
-                hStartIndex = hEndIndex;
-            } while (hStartIndex < hLength);
+                        // Row length will always be spillPerpendicular or spillPerpendicular - 1.
+                        if (row.length < spillPerpendicular) {
+                            row[spillPerpendicular - 1] = "";
+                        }
+
+                        result.push(row);
+                    }
+                }
+            } else {
+                // Return matrix unmodified and let application handle spill error if any.
+                result = matrixValues;
+            }
         } else {
-            // Return matrix unmodified and let application handle spill error if any.
-            result = hMatrixValues;
+            // Return error as only element in matrix.
+            result = [[isArrayOrError]];
         }
 
         return result;
     }
 
     /**
-     * Spill a vertical matrix horizontally to fit within a maximum width and height.
+     * Get the logger messages as a stream.
      *
-     * @param vMatrixValues
-     * Vertical matrix values. Matrix contains arrays of length 1 with the values.
+     * @param logLevelString
+     * Log level as string.
      *
-     * @param maximumHeight
-     * Maximum height.
-     *
-     * @param maximumWidth
-     * Maximum width.
-     *
-     * @param invocationContext
-     * Invocation context.
-     *
-     * @returns
-     * Matrix spilled within maximum height and maximum width.
+     * @param streamingInvocationContext
+     * Streaming invocation context.
      */
     @proxy.describeMethod({
-        requiresContext: true,
-        type: Types.Any,
+        type: Types.String,
+        isHidden: true,
+        isStream: true,
         isMatrix: true,
-        parameterDescriptors: [spillMatrix, spillMaximumHeightParameterDescriptor, spillMaximumWidthParameterDescriptor]
+        parameterDescriptors: [{
+            name: "logLevel",
+            type: Types.String,
+            isMatrix: false,
+            isRequired: false
+        }]
     })
-    async hSpill(vMatrixValues: Matrix<unknown>, maximumHeight: Nullishable<number>, maximumWidth: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>> {
-        let result: Matrix<unknown>;
-
-        for (const hArrayValues of vMatrixValues) {
-            // This test should be necessary only once but account for zero-size matrix and misuse of method.
-            if (hArrayValues.length !== 1) {
-                throw new RangeError(i18nextAppExtension.t("Proxy.hSpillMustBeVerticalArray"));
-            }
+    loggerMessages(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");
         }
 
-        const maximumDimensions = await this.#defaultMaximums({
-            width: maximumWidth,
-            height: maximumHeight
-        }, invocationContext);
-
-        const vLength = vMatrixValues.length;
-        const maximumArea = maximumDimensions.width * maximumDimensions.height;
+        const appExtension = this.appExtension;
 
-        // Lengths 0 and 1 are valid and require no special processing.
-        if (vLength > 1 && vLength <= maximumArea) {
-            // Make spill as square as possible.
-            let spillHeight = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.height);
+        let notificationCallbackAdded = false;
+        let previousLogLevel: number | undefined = undefined;
 
-            // Array that has a length of a power of 10 is treated specially.
-            if (Number.isInteger(Math.log10(vLength))) {
-                // Try spill height that is a power of 10.
-                const spillHeight10 = 10 ** Math.floor(Math.log10(spillHeight));
+        const streamingConsumerCallback = appExtension.setUpStreaming<string>(streamingInvocationContext, () => {
+            if (notificationCallbackAdded) {
+                appExtension.memoryTransport.removeNotificationCallback("loggerMessages");
+            }
 
-                // Keep default if not enough space for power of 10 matrix.
-                if (vLength / spillHeight10 <= maximumDimensions.width) {
-                    spillHeight = spillHeight10;
-                }
+            if (previousLogLevel !== undefined) {
+                appExtension.logger.settings.minLevel = previousLogLevel;
             }
+        });
 
-            result = [];
+        if (appExtension.memoryTransport.addNotificationCallback("loggerMessages", (_message, messages) => {
+            streamingConsumerCallback(this.iterableResult(() => messages));
+        })) {
+            notificationCallbackAdded = true;
 
-            for (let rowIndex = 0; rowIndex < spillHeight; rowIndex++) {
-                const row = new Array<unknown>();
+            let logLevel: LogLevel | undefined = undefined;
 
-                for (let cellIndex = rowIndex; cellIndex < vLength; cellIndex++) {
-                    row.push(vMatrixValues[cellIndex][0]);
+            if (!isNullish(logLevelString)) {
+                try {
+                    logLevel = logLevelOf(logLevelString);
+                } catch {
+                    // Ignore error.
                 }
+            }
 
-                result.push(row);
+            // Set log level if required.
+            if (logLevel !== undefined) {
+                previousLogLevel = appExtension.logger.settings.minLevel;
+                appExtension.logger.settings.minLevel = logLevel;
             }
         } else {
-            // Return matrix unmodified and let application handle spill error if any.
-            result = vMatrixValues;
+            // Diagnostic tool; localization not required.
+            streamingConsumerCallback([["Only one logger messages call allowable per workbook"]]);
         }
-
-        return result;
     }
 }

package/src/descriptor.ts

@@ -53,7 +53,7 @@ interface TypeDescriptor extends Descriptor {
     readonly type: Type;
 
     /**
-     * True if type is a matrix (method accepts or returns a two-dimensional array).
+     * True if type is a matrix (method accepts or returns, or parameter is, a two-dimensional array).
      */
     readonly isMatrix: boolean;
 }
@@ -83,6 +83,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 +107,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.
      */
@@ -134,12 +164,9 @@ export interface ClassDescriptor extends Descriptor {
     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,4 +1,4 @@
-import { I18nEnvironments } from "@aidc-toolkit/core";
+import { I18nEnvironments, type Promisable } from "@aidc-toolkit/core";
 import type { ParseKeys } from "i18next";
 import { AppUtilityProxy } from "../app-utility-proxy.js";
 import type { ClassDescriptor, MethodDescriptor } from "../descriptor.js";
@@ -17,6 +17,7 @@ function registerProxies(..._proxies: unknown[]): void {
 }
 
 registerProxies(AppUtilityProxy, Utility, GS1);
+
 /**
  * Localization.
  */
@@ -181,7 +182,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.
@@ -195,20 +196,23 @@ export abstract class Generator {
      * @param localizedKeyPrefix
      * Localized key prefix.
      *
+     * @param namespacePrefix
+     * Namespace prefix to be appended to name.
+     *
      * @param localizationCallback
      * Callback to finalize localization.
      *
      * @returns
      * Localization.
      */
-    #generateLocalization<TLocalization extends Localization>(locale: string, localizedKeyPrefix: string, localizationCallback: (locale: string, localization: Localization) => TLocalization): TLocalization {
+    #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: i18nextAppExtension.t(`${localizedKeyPrefix}name` as ParseKeys, lngOption),
+            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)
         });
@@ -222,28 +226,25 @@ 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();
 
         try {
             for (const [_namespaceClassName, classDescriptor] of proxy.classDescriptorsMap.entries()) {
                 const namespace = classDescriptor.namespace;
+                const namespacePrefix = namespace === undefined ? "" : `${namespace}.`;
+                const namespacePath = namespace === undefined ? "" : `${namespace}/`;
 
                 this.createProxyObject(classDescriptor);
 
                 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}.`, (locale, localization) => ({
+                        [locale, this.#generateLocalization<FunctionLocalization>(locale, `Functions.${namespaceFunctionName}.`, namespacePrefix, (locale, localization) => ({
                             ...localization,
-                            documentationURL: `${Generator.#DOCUMENTATION_BASE_URL}${locale === this.defaultLocale ? "" : `${locale}/`}${Generator.#DOCUMENTATION_PATH}${namespace === undefined ? "" : `${namespace}/`}${localization.name}.html`,
+                            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)]
+                                [parameterDescriptor.name, this.#generateLocalization(locale, `Parameters.${parameterDescriptor.name}.`, "", (_locale, localization) => localization)]
                             ))
                         }))]
                     ));

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

@@ -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>;
 
 /**
@@ -187,40 +186,43 @@ 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);
-        }
+        // 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 ***"
+            };
+        }
     }
 
     /**

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