node-opcua-address-space-for-conformance-testing 2.167.0 → 2.169.0

package/src/conformance_testing/node_with_references.ts

@@ -0,0 +1,130 @@
+/**
+ * Reference test nodes for CTT conformance testing.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+
+export function addNodeWithReferences(namespace: Namespace, simulation_folder: UAObject): void {
+    const parent = simulation_folder;
+    const referenceFolder = namespace.addObject({
+        browseName: "References",
+        nodeId: "s=Demo.CTT.References",
+        organizedBy: parent,
+        typeDefinition: "FolderType"
+    });
+
+    // --- Has3ForwardReferences1: 3 variable components ---
+    {
+        const has3ForwardReferences1 = namespace.addObject({
+            browseName: "Has3ForwardReferences1",
+            nodeId: "s=Demo.CTT.References.Has3ForwardReferences1",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        namespace.addVariable({ browseName: "ReferenceNode1", componentOf: has3ForwardReferences1, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode2", componentOf: has3ForwardReferences1, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode3", componentOf: has3ForwardReferences1, dataType: "UInt32" });
+    }
+
+    // --- Has3ForwardReferences2: variable + 3 methods + property ---
+    {
+        const has3ForwardReferences2 = namespace.addObject({
+            browseName: "Has3ForwardReferences2",
+            nodeId: "s=Demo.CTT.References.Has3ForwardReferences2",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        namespace.addVariable({ browseName: "BaseDataVariable", componentOf: has3ForwardReferences2, dataType: "UInt32" });
+        namespace.addMethod(has3ForwardReferences2, { browseName: "Method1" });
+        namespace.addMethod(has3ForwardReferences2, { browseName: "Method2" });
+        namespace.addMethod(has3ForwardReferences2, { browseName: "Method3" });
+        namespace.addVariable({ browseName: "Property", propertyOf: has3ForwardReferences2, dataType: "UInt32" });
+    }
+
+    // --- Has3ForwardReferences3 + Has3InverseReferences ---
+    {
+        const has3ForwardReferences3 = namespace.addObject({
+            browseName: "Has3ForwardReferences3",
+            nodeId: "s=Demo.CTT.References.Has3ForwardReferences3",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        const referencedNode1 = namespace.addFolder(has3ForwardReferences3, "ReferencedNode1");
+        const referencedNode2 = namespace.addFolder(has3ForwardReferences3, "ReferencedNode2");
+        const referencedNode3 = namespace.addFolder(has3ForwardReferences3, "ReferencedNode3");
+
+        const has3InverseReferences = namespace.addObject({
+            browseName: "Has3InverseReferences",
+            nodeId: "s=Demo.CTT.References.Has3InverseReferences",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+
+        referencedNode1.addReference({ referenceType: "Organizes", nodeId: has3InverseReferences });
+        referencedNode2.addReference({ referenceType: "Organizes", nodeId: has3InverseReferences });
+        referencedNode3.addReference({ referenceType: "Organizes", nodeId: has3InverseReferences });
+    }
+
+    // --- Has3ForwardReferences4: 3 properties ---
+    {
+        const has3ForwardReferences4 = namespace.addObject({
+            browseName: "Has3ForwardReferences4",
+            nodeId: "s=Demo.CTT.References.Has3ForwardReferences4",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        namespace.addVariable({ browseName: "ReferenceNode1", propertyOf: has3ForwardReferences4, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode2", propertyOf: has3ForwardReferences4, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode3", propertyOf: has3ForwardReferences4, dataType: "UInt32" });
+    }
+
+    // --- Has3ForwardReferences5: folder + property + method ---
+    {
+        const has3ForwardReferences5 = namespace.addObject({
+            browseName: "Has3ForwardReferences5",
+            nodeId: "s=Demo.CTT.References.Has3ForwardReferences5",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        namespace.addFolder(has3ForwardReferences5, { browseName: "ReferenceNode1" });
+        namespace.addVariable({ browseName: "ReferenceNode2", propertyOf: has3ForwardReferences5, dataType: "UInt32" });
+        namespace.addMethod(has3ForwardReferences5, { browseName: "ReferenceNode3" });
+    }
+
+    // --- HasInverseAndForwardReferences ---
+    {
+        const hasInverseAndForwardReferences = namespace.addObject({
+            browseName: "HasInverseAndForwardReferences",
+            nodeId: "s=Demo.CTT.References.HasInverseAndForwardReferences",
+            componentOf: referenceFolder,
+            typeDefinition: "FolderType"
+        });
+        const nodeId = namespace.addFolder(hasInverseAndForwardReferences, { browseName: "ReferenceNode1" });
+        hasInverseAndForwardReferences.addReference({ nodeId, referenceType: "AlarmGroupMember" });
+    }
+
+    // --- HasReferencesWithDifferentParentTypes ---
+    namespace.addObject({
+        browseName: "HasReferencesWithDifferentParentTypes",
+        nodeId: "s=Demo.CTT.References.HasReferencesWithDifferentParentTypes",
+        componentOf: referenceFolder,
+        typeDefinition: "FolderType"
+    });
+
+    // --- HasReferencesOfAReferenceTypeAndSubType ---
+    {
+        const hasReferencesOfAReferenceTypeAndSubType = namespace.addObject({
+            browseName: "HasReferencesOfAReferenceTypeAndSubType",
+            nodeId: "s=Demo.CTT.References.HasReferencesOfAReferenceTypeAndSubType",
+            typeDefinition: "FolderType",
+            componentOf: referenceFolder
+        });
+        namespace.addVariable({ browseName: "ReferenceNode1", propertyOf: hasReferencesOfAReferenceTypeAndSubType, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode2", propertyOf: hasReferencesOfAReferenceTypeAndSubType, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode3", propertyOf: hasReferencesOfAReferenceTypeAndSubType, dataType: "UInt32" });
+        namespace.addVariable({ browseName: "ReferenceNode4", propertyOf: hasReferencesOfAReferenceTypeAndSubType, dataType: "UInt32" });
+        for (let i = 0; i < 4; i++) {
+            const a = namespace.addObject({ browseName: `AlarmSuppressionGroup${i}`, componentOf: referenceFolder });
+            hasReferencesOfAReferenceTypeAndSubType.addReference({ nodeId: a, referenceType: "HasAlarmSuppressionGroup" });
+        }
+    }
+}

package/src/conformance_testing/object_with_methods.ts

@@ -0,0 +1,93 @@
+/**
+ * Object with methods for conformance testing (MethodNoArgs, MethodIO, MethodI, MethodO).
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+import { assert } from "node-opcua-assert";
+import { makeNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+
+export function addObjectWithMethod(namespace: Namespace, parentFolder: UAObject) {
+    const myObject = namespace.addObject({
+        nodeId: "s=ObjectWithMethods",
+        organizedBy: parentFolder,
+        browseName: "ObjectWithMethods"
+    });
+
+    // MethodNoArgs
+    const methodNoArgs = namespace.addMethod(myObject, {
+        browseName: "MethodNoArgs",
+        nodeId: "s=MethodNoArgs"
+    });
+    assert(
+        makeNodeId("MethodNoArgs", namespace.index)
+            .toString()
+            .match(/s=MethodNoArgs/)
+    );
+    assert(methodNoArgs.nodeId.toString().match(/s=MethodNoArgs/));
+
+    methodNoArgs.bindMethod((_inputArguments, _context, callback) => {
+        callback(null, { statusCode: StatusCodes.Good, outputArguments: [] });
+    });
+
+    // MethodIO (input + output)
+    const methodIO = namespace.addMethod(myObject, {
+        browseName: "MethodIO",
+        nodeId: makeNodeId("MethodIO", namespace.index),
+        inputArguments: [
+            {
+                name: "ShutterLag",
+                description: { text: "specifies the number of seconds to wait before the picture is taken " },
+                dataType: DataType.UInt32
+            }
+        ],
+        outputArguments: [
+            {
+                name: "Result",
+                description: { text: "the result" },
+                dataType: "Int32"
+            }
+        ]
+    });
+    methodIO.bindMethod((_inputArguments, _context, callback) => {
+        callback(null, {
+            statusCode: StatusCodes.Good,
+            outputArguments: [{ dataType: DataType.Int32, value: 42 }]
+        });
+    });
+
+    // MethodI (input only)
+    const methodI = namespace.addMethod(myObject, {
+        browseName: "MethodI",
+        nodeId: "s=MethodI",
+        inputArguments: [
+            {
+                name: "ShutterLag",
+                description: { text: "specifies the number of seconds to wait before the picture is taken " },
+                dataType: DataType.UInt32
+            }
+        ]
+    });
+    methodI.bindMethod((_inputArguments, _context, callback) => {
+        callback(null, { statusCode: StatusCodes.Good, outputArguments: [] });
+    });
+
+    // MethodO (output only)
+    const methodO = namespace.addMethod(myObject, {
+        browseName: "MethodO",
+        nodeId: "s=MethodO",
+        outputArguments: [
+            {
+                name: "Result",
+                description: { text: "the result" },
+                dataType: "Int32"
+            }
+        ]
+    });
+    methodO.bindMethod((_inputArguments, _context, callback) => {
+        callback(null, {
+            statusCode: StatusCodes.Good,
+            outputArguments: [{ dataType: DataType.Int32, value: 42 }]
+        });
+    });
+}

package/src/conformance_testing/path_and_large_arrays.ts

@@ -0,0 +1,35 @@
+/**
+ * 10-deep path and very large array variables for conformance testing.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+
+import { addArrayVariable } from "./helpers";
+import { typeAndDefaultValue } from "./type_defaults";
+
+export function addPath10Deep(namespace: Namespace, simulation_folder: UAObject) {
+    let parent = simulation_folder;
+    for (let i = 1; i <= 10; i++) {
+        const name = `Path_${i.toString()}Deep`;
+        const child = namespace.addObject({
+            organizedBy: parent,
+            browseName: name,
+            description: `A folder at the top of ${i} elements`,
+            typeDefinition: "FolderType",
+            nodeId: `s=${name}`
+        });
+        parent = child;
+    }
+}
+
+export function addVeryLargeArrayVariables(namespace: Namespace, objectsFolder: UAObject): void {
+    const scalarStaticLargeArray = namespace.addObject({
+        organizedBy: objectsFolder,
+        browseName: "Static_Scalar_Large_Array",
+        description: "Single dimension, suggested size of 100k-elements per array.",
+        nodeId: "s=Static_Scalar_Large_Array"
+    });
+    for (const e of typeAndDefaultValue) {
+        const realType = e.realType || e.type;
+        addArrayVariable(namespace, scalarStaticLargeArray, e.type, e.defaultValue, realType, 50 * 1024, "");
+    }
+}

package/src/conformance_testing/sample_view.ts

@@ -0,0 +1,28 @@
+/**
+ * Sample views for conformance testing.
+ */
+import type { Namespace } from "node-opcua-address-space";
+
+export function addSampleView(namespace: Namespace): void {
+    const addressSpace = namespace.addressSpace;
+
+    const view1 = namespace.addView({
+        organizedBy: addressSpace.rootFolder.views,
+        browseName: "SampleView",
+        nodeId: "s=SampleView"
+    });
+    view1.addReference({
+        nodeId: "i=2256", // Server_Status
+        referenceType: "Organizes"
+    });
+    view1.addReference({
+        nodeId: "i=11715", // Server_Namespaces
+        referenceType: "Organizes"
+    });
+
+    namespace.addView({
+        organizedBy: addressSpace.rootFolder.views,
+        browseName: "OtherSampleView",
+        nodeId: "s=OtherSampleView"
+    });
+}

package/src/conformance_testing/simulation_variables.ts

@@ -0,0 +1,129 @@
+/**
+ * Simulation (dynamic) variables that change randomly on a timer.
+ */
+import type { Namespace, UAObject, UAVariable } from "node-opcua-address-space";
+import { assert } from "node-opcua-assert";
+import { isValidBoolean, isValidUInt16 } from "node-opcua-basic-types";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+
+import { addVariable, findDataType, getRandomFuncForType } from "./helpers";
+import { typeAndDefaultValue } from "./type_defaults";
+
+export function addSimulationVariables(namespace: Namespace, scalarFolder: UAObject): void {
+    let values_to_change: { dataType: DataType; randomFunc: () => unknown; variable: UAVariable }[] = [];
+
+    function add_simulation_variable(parent: UAObject, dataTypeName: string, defaultValue: unknown, realTypeName: string): UAVariable {
+        realTypeName = realTypeName || dataTypeName;
+        const dataType = findDataType(realTypeName);
+        const randomFunc = getRandomFuncForType(dataType);
+
+        // c8 ignore next
+        if (typeof randomFunc !== "function") {
+            throw new Error(`a random function must exist for basicType ${dataTypeName}`);
+        }
+
+        const variable = addVariable(namespace, parent, dataTypeName, realTypeName, defaultValue, -1, null, "");
+        values_to_change.push({ dataType, randomFunc, variable });
+        return variable;
+    }
+
+    const simulation = namespace.addObject({
+        browseName: "Scalar_Simulation",
+        description: "This folder will contain one item per supported data-type.",
+        nodeId: "s=Scalar_Simulation",
+        organizedBy: scalarFolder
+    });
+
+    for (const e of typeAndDefaultValue) {
+        const dataType = e.type;
+        const defaultValue = typeof e.defaultValue === "function" ? e.defaultValue() : e.defaultValue;
+        const realType = e.realType || dataType;
+        add_simulation_variable(simulation, dataType, defaultValue, realType);
+    }
+
+    // Management nodes
+    let interval = 2000;
+    let enabled = true;
+    let timer: NodeJS.Timeout | undefined;
+
+    function change_randomly() {
+        for (const element of values_to_change) {
+            const variant = (element.variable as unknown as Record<string, { variant: Variant }>)._backdoor_placeholder.variant;
+            variant.value = element.randomFunc();
+            element.variable.setValueFromSource(variant);
+        }
+    }
+
+    function delete_Timer() {
+        if (timer) {
+            try {
+                clearInterval(timer);
+            } catch (_err) {
+                /* c8 ignore next */
+                // the leak detector may throw if the timer handle is already disposed
+            }
+            timer = undefined;
+        }
+    }
+
+    function install_Timer() {
+        delete_Timer();
+        assert(!timer);
+        if (enabled) {
+            timer = setInterval(() => {
+                change_randomly();
+            }, interval);
+        }
+    }
+
+    function tearDown_Timer() {
+        delete_Timer();
+        values_to_change = [];
+    }
+
+    const intervalVariable = namespace.addVariable({
+        browseName: "Interval",
+        componentOf: simulation,
+        dataType: "UInt16",
+        description: { locale: "en", text: "The rate (in msec) of change for all Simulated items." },
+        nodeId: "s=Scalar_Simulation_Interval",
+        value: new Variant({
+            arrayType: VariantArrayType.Scalar,
+            dataType: DataType.UInt16,
+            value: interval
+        })
+    });
+
+    intervalVariable.on("value_changed", (dataValue /*,indexRange*/) => {
+        const variant = dataValue.value;
+        assert(variant instanceof Variant);
+        assert(isValidUInt16(variant.value), " value must be valid for dataType");
+        interval = variant.value;
+        install_Timer();
+    });
+
+    const enabledVariable = namespace.addVariable({
+        componentOf: simulation,
+        browseName: "Enabled",
+        description: { locale: "en", text: "Enabled" },
+        nodeId: "s=Scalar_Simulation_Enabled",
+        dataType: "Boolean",
+        value: new Variant({
+            dataType: DataType.Boolean,
+            arrayType: VariantArrayType.Scalar,
+            value: enabled
+        })
+    });
+
+    enabledVariable.on("value_changed", (dataValue /*,indexRange*/) => {
+        const variant = dataValue.value;
+        assert(variant instanceof Variant);
+        assert(isValidBoolean(variant.value), " value must be valid for dataType");
+        enabled = variant.value;
+        install_Timer();
+    });
+    install_Timer();
+
+    const addressSpace = namespace.addressSpace;
+    addressSpace.registerShutdownTask(tearDown_Timer);
+}

package/src/conformance_testing/static_variables.ts

@@ -0,0 +1,71 @@
+/**
+ * Static scalar, array, and multi-dimensional array variables + image loading.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import type { Namespace, UAObject, UAVariable } from "node-opcua-address-space";
+import { make_errorLog } from "node-opcua-debug";
+import { DataType, Variant } from "node-opcua-variant";
+
+import { addArrayVariable, addMultiDimensionalArrayVariable, addScalarVariable } from "./helpers";
+import { typeAndDefaultValue } from "./type_defaults";
+
+const errorLog = make_errorLog(__filename);
+
+export async function addStaticVariables(namespace: Namespace, scalarFolder: UAObject): Promise<void> {
+    const staticScalarFolder = namespace.addObject({
+        organizedBy: scalarFolder,
+        browseName: "Scalars",
+        description: "This folder will contain one item per supported data-type.",
+        nodeId: "s=Static_Scalar"
+    });
+
+    // Scalar variables
+    for (const e of typeAndDefaultValue) {
+        const dataType = e.type;
+        const realType = e.realType || dataType;
+        const defaultValue = typeof e.defaultValue === "function" ? e.defaultValue() : e.defaultValue;
+        addScalarVariable(namespace, staticScalarFolder, dataType, realType, defaultValue, "");
+    }
+
+    // Load images
+    async function setImage(imageType: string, filename: string): Promise<void> {
+        const fullPath = path.join(__dirname, "../../data", filename);
+        const imageNode = namespace.findNode(`s=Static_Scalar_Image${imageType}`) as UAVariable;
+        try {
+            const data = await fs.promises.readFile(fullPath);
+            imageNode.setValueFromSource(new Variant({ dataType: DataType.ByteString, value: data }));
+        } catch (_err) {
+            errorLog("cannot load file =", fullPath);
+        }
+    }
+
+    await setImage("BMP", "image.bmp");
+    await setImage("PNG", "tux.png");
+    await setImage("GIF", "gif-anime.gif");
+    await setImage("JPG", "tiger.jpg");
+
+    // Array variables
+    const staticArraysFolders = namespace.addObject({
+        organizedBy: scalarFolder,
+        browseName: "Arrays",
+        description: "Single dimension, suggested size of 10-elements per array. Unsupported types will be missing from the address-space.",
+        nodeId: "s=Static_Array"
+    });
+    for (const e of typeAndDefaultValue) {
+        const realType = e.realType || e.type;
+        addArrayVariable(namespace, staticArraysFolders, e.type, e.defaultValue, realType, 10, "");
+    }
+
+    // Multi-dimensional array variables
+    const staticMultiDimensionalArrays = namespace.addObject({
+        organizedBy: scalarFolder,
+        browseName: "Multi-Dimensional Arrays",
+        description: "Single dimension, suggested size of 10-elements per array. Unsupported types will be missing from the address-space.",
+        nodeId: "s=Static_MultiDimensional_Array"
+    });
+    for (const e of typeAndDefaultValue) {
+        const realType = e.realType || e.type;
+        addMultiDimensionalArrayVariable(namespace, staticMultiDimensionalArrays, e.type, e.defaultValue, realType, 2, 3, "");
+    }
+}

package/src/conformance_testing/trigger_nodes.ts

@@ -0,0 +1,49 @@
+/**
+ * Trigger nodes that raise events on write.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+import type { NodeIdLike } from "node-opcua-nodeid";
+import { makeNodeId } from "node-opcua-nodeid";
+import { DataType, Variant } from "node-opcua-variant";
+
+export function addTriggerNodes(namespace: Namespace, parentFolder: UAObject): void {
+    const addressSpace = namespace.addressSpace;
+
+    const myEvtType =
+        namespace.findObjectType("MyEventType") ||
+        namespace.addEventType({
+            browseName: "MyEventType",
+            subtypeOf: "BaseEventType"
+        });
+
+    function _add_trigger_node(parent: UAObject, browseName: string, nodeId: NodeIdLike) {
+        const triggerNode = namespace.addVariable({
+            browseName,
+            nodeId,
+            eventSourceOf: parent,
+            dataType: "Double",
+            typeDefinition: makeNodeId(68)
+        });
+
+        let value = 100.0;
+        const getFunc = () => new Variant({ dataType: DataType.Double, value });
+        const setFunc = (variant: Variant) => {
+            value = variant.value;
+            const server = addressSpace.rootFolder.objects.server;
+            server.raiseEvent(myEvtType, {
+                message: { dataType: DataType.LocalizedText, value: { text: "Hello World" } },
+                severity: { dataType: DataType.UInt32, value: 32 }
+            });
+        };
+
+        triggerNode.bindVariable({ get: getFunc, set: setFunc });
+    }
+
+    const sampleTriggerNode = namespace.addObject({
+        browseName: "SampleTriggerNode",
+        eventNotifier: 0x1,
+        organizedBy: parentFolder
+    });
+    _add_trigger_node(sampleTriggerNode, "TriggerNode01", "s=TriggerNode01");
+    _add_trigger_node(sampleTriggerNode, "TriggerNode02", "s=TriggerNode02");
+}

package/src/conformance_testing/type_defaults.ts

@@ -0,0 +1,60 @@
+/**
+ * Default type/value table shared by static, simulation, mass, and large array builders.
+ */
+import { emptyGuid } from "node-opcua-basic-types";
+import * as ec from "node-opcua-basic-types";
+import { LocalizedText, QualifiedName } from "node-opcua-data-model";
+import { coerceNodeId } from "node-opcua-nodeid";
+
+export const typeAndDefaultValue = [
+    { type: "Boolean", defaultValue: false },
+    { type: "ByteString", defaultValue: Buffer.from("OPCUA") },
+    { type: "DateTime", defaultValue: ec.getMinOPCUADate() },
+    { type: "Double", defaultValue: 0.0 },
+    { type: "Float", defaultValue: 0.0 },
+    { type: "Guid", defaultValue: emptyGuid },
+    { type: "SByte", defaultValue: 0 },
+    { type: "Int16", defaultValue: 0 },
+    { type: "Int32", defaultValue: 0 },
+    {
+        type: "NodeId",
+        defaultValue() {
+            return coerceNodeId(`ns=${3};g=00000000-0000-0000-0000-000000000023`);
+        }
+    },
+    { type: "String", defaultValue: "OPCUA" },
+    { type: "Byte", defaultValue: 0 },
+    { type: "UInt16", defaultValue: 0 },
+    { type: "UInt32", defaultValue: 0 },
+    { type: "Duration", realType: "Double", defaultValue: 0.0 },
+    { type: "Number", realType: "UInt16", defaultValue: 0 }, // Number is abstract
+    { type: "Integer", realType: "Int64", defaultValue: 0 }, // because Integer is abstract, we choose Int64
+    { type: "UInteger", realType: "UInt64", defaultValue: 0 },
+    {
+        type: "UtcTime",
+        realType: "DateTime",
+        defaultValue() {
+            return new Date();
+        }
+    },
+    { type: "LocaleId", realType: "String", defaultValue: "" },
+    {
+        type: "LocalizedText",
+        defaultValue() {
+            return new LocalizedText({});
+        }
+    },
+    {
+        type: "QualifiedName",
+        defaultValue() {
+            return new QualifiedName();
+        }
+    },
+    { type: "UInt64", defaultValue: [0, 0] },
+    { type: "Int64", defaultValue: [0, 0] },
+    { type: "XmlElement", defaultValue: "<string1>OPCUA</string1>" },
+    { type: "ImageBMP", realType: "ByteString", defaultValue: null },
+    { type: "ImageGIF", realType: "ByteString", defaultValue: null },
+    { type: "ImageJPG", realType: "ByteString", defaultValue: null },
+    { type: "ImagePNG", realType: "ByteString", defaultValue: null }
+];