node-opcua-convert-nodeset-to-javascript 2.178.0 → 2.180.0

package/source/private/cache.ts

@@ -1,11 +1,11 @@
-import path from "path";
+import path from "node:path";
+import { kebabCase } from "case-anything";
 import assert from "node-opcua-assert";
 import { AttributeIds, NodeClass, QualifiedName } from "node-opcua-data-model";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
-import { DataTypeDefinition, EnumDefinition } from "node-opcua-types";
-import { kebabCase } from "case-anything";
-import { Options } from "../options";
+import { type NodeId, resolveNodeId } from "node-opcua-nodeid";
+import type { IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
+import { type DataTypeDefinition, EnumDefinition } from "node-opcua-types";
+import type { Options } from "../options";
 import { getBrowseName, getDefinition } from "./utils";
 
 export interface Import {
@@ -33,7 +33,7 @@ interface RequestedSymbol {
     }[];
 }
 export function makeName2(name: string) {
-    return "U" + name;
+    return `U${name}`;
     // if (name === "EUInformation") {
     //     return "EUInformation2";
     // }
@@ -57,7 +57,7 @@ export class Cache implements CacheInterface {
             "node-opcua-variant": {
                 DataType: 1,
                 Variant: 1,
-                VariantOptions: 1,
+                VariantOptions: 1
             },
             "node-opcua-data-model": {
                 LocalizedText: 1,
@@ -120,10 +120,11 @@ export class Cache implements CacheInterface {
         {
             const sourceFolder = this.namespace[namespaceIndex]?.sourceFolder;
             if (!sourceFolder) {
-                throw new Error("Cannot find namespace  " + namespaceIndex);
+                throw new Error(`Cannot find namespace  ${namespaceIndex}`);
             }
         }
-        const symbols = (this.namespace[namespaceIndex].symbols = this.namespace[namespaceIndex].symbols || {});
+        this.namespace[namespaceIndex].symbols = this.namespace[namespaceIndex].symbols || {};
+        const symbols = this.namespace[namespaceIndex].symbols;
         symbols[typeName] = (symbols[typeName] || 0) + 1;
 
         const ns = this.requestedSymbols.namespace[namespaceIndex] || { symbols: {} };
@@ -134,7 +135,8 @@ export class Cache implements CacheInterface {
         if (!mainTypeName) {
             mainTypeName = typeName;
         }
-        const subs = (ns.symbols[mainTypeName] = ns.symbols[mainTypeName] || { subSymbols: {} });
+        ns.symbols[mainTypeName] = ns.symbols[mainTypeName] || { subSymbols: {} };
+        const subs = ns.symbols[mainTypeName];
         subs.subSymbols[typeName] = (subs.subSymbols[typeName] || 0) + 1;
     }
 
@@ -157,7 +159,10 @@ function getSourceFolderForNamespace(browseName: QualifiedName, options: Options
     return { sourceFolder, module };
 }
 
-export async function referenceExtensionObject(session: IBasicSessionReadAsyncSimple, extensionObjectDataType: NodeId): Promise<Import> {
+export async function referenceExtensionObject(
+    session: IBasicSessionReadAsyncSimple,
+    extensionObjectDataType: NodeId
+): Promise<Import> {
     const browseName = await getBrowseName(session, extensionObjectDataType);
     const definition = await getDefinition(session, extensionObjectDataType);
     const dataTypeNameImport = makeTypeNameNew(NodeClass.DataType, definition, browseName);
@@ -214,8 +219,10 @@ export function makeTypeNameNew(
     suffix?: string
 ): Import {
     assert(browseName && !!browseName.name, "expecting a class name here");
-
-    const typeName = browseName.name!.toString();
+    if (!browseName.name) {
+        throw new Error("expecting a class name here");
+    }
+    const typeName = browseName.name.toString();
     if (typeName === "EUInformation") {
         return makeBasicTypeImport("EUInformation");
     } else if (typeName === "Enumeration") {
@@ -235,7 +242,7 @@ export function makeTypeNameNew(
             case NodeClass.Object:
             case NodeClass.VariableType:
             case NodeClass.ObjectType:
-                name = `UA${typeName.replace(/Type$/, "")}` + (suffix || "");
+                name = `UA${typeName.replace(/Type$/, "")}${suffix || ""}`;
                 break;
             case NodeClass.DataType:
                 if (definition instanceof EnumDefinition) {
@@ -246,7 +253,7 @@ export function makeTypeNameNew(
                 break;
         }
         if (name === "") {
-            throw new Error("Internal Error " + NodeClass[nodeClass] + " " + typeName + "browseName = " + browseName.toString());
+            throw new Error(`Internal Error ${NodeClass[nodeClass]} ${typeName}browseName = ${browseName.toString()}`);
         }
         return { name, module: name, namespace: browseName.namespaceIndex };
     }

package/source/private/fs_retry.ts

@@ -22,7 +22,9 @@ export function retryOnTransientWrite<T>(write: () => T, attempts = 6): T {
         } catch (err) {
             if (!isTransientWriteError(err) || i === attempts - 1) throw err;
             const until = Date.now() + 50 * (i + 1);
-            while (Date.now() < until) { /* spin */ }
+            while (Date.now() < until) {
+                /* spin */
+            }
         }
     }
 }

package/source/private/get_corresponding_data_type.ts

@@ -1,9 +1,9 @@
-import { NodeId } from "node-opcua-nodeid";
-import { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
+import type { NodeId } from "node-opcua-nodeid";
+import type { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
 import { DataType } from "node-opcua-variant";
-import { Import, referenceEnumeration, referenceExtensionObject } from "./cache";
-import { getValueRank, _convertNodeIdToDataTypeAsync } from "./utils";
-import { Cache } from "./cache";
+import type { Cache } from "./cache";
+import { type Import, referenceEnumeration, referenceExtensionObject } from "./cache";
+import { _convertNodeIdToDataTypeAsync, getValueRank } from "./utils";
 
 export async function getCorrespondingJavascriptType2(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
@@ -11,12 +11,17 @@ export async function getCorrespondingJavascriptType2(
     dataTypeNodeId: NodeId,
     cache: Cache,
     importCollect?: (t: Import) => void
-): Promise<{ dataType: DataType; jtype: string, dataTypeCombination?: string, type: "enum" | "basic" | "genericNumber"}> {
-    const { dataType, jtype, dataTypeCombination, type} = await getCorrespondingJavascriptType(session, dataTypeNodeId, cache, importCollect);
+): Promise<{ dataType: DataType; jtype: string; dataTypeCombination?: string; type: "enum" | "basic" | "genericNumber" }> {
+    const { dataType, jtype, dataTypeCombination, type } = await getCorrespondingJavascriptType(
+        session,
+        dataTypeNodeId,
+        cache,
+        importCollect
+    );
     const valueRank = await getValueRank(session, nodeId);
     let jtype2 = "";
     if (valueRank >= 0) {
-        jtype2 = jtype + "[]";
+        jtype2 = `${jtype}[]`;
     } else if (valueRank === -1) {
         jtype2 = jtype;
     } else if (valueRank === -2) {
@@ -26,50 +31,48 @@ export async function getCorrespondingJavascriptType2(
         // ScalarOrOneDimension (-3):  The value can be a scalar or a one dimensional array.
         jtype2 = `(${jtype} | ${jtype}[])`;
     } else {
-        throw new Error("Invalid valueRank " + valueRank);
+        throw new Error(`Invalid valueRank ${valueRank}`);
     }
     return { dataType: dataType, jtype: jtype2, dataTypeCombination, type };
 }
 
-// eslint-disable-next-line complexity
 export async function getCorrespondingJavascriptType(
     session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
     dataTypeNodeId: NodeId,
     cache: Cache,
     importCollect?: (t: Import) => void
-): Promise<{ 
-    enumerationType?: string; 
-    dataType: DataType; 
-    jtype: string,
-    type: "enum" | "basic" | "genericNumber",
-    dataTypeCombination?: string
- }> {
-
+): Promise<{
+    enumerationType?: string;
+    dataType: DataType;
+    jtype: string;
+    type: "enum" | "basic" | "genericNumber";
+    dataTypeCombination?: string;
+}> {
     const info = await _convertNodeIdToDataTypeAsync(session, dataTypeNodeId);
     const { type } = info;
 
-    if (type == "enum" && info.enumerationType) {
+    if (type === "enum" && info.enumerationType) {
         // we have a enmeration name here
         const jtypeImport = await referenceEnumeration(session, dataTypeNodeId);
         const jtype = jtypeImport.name;
-        importCollect && importCollect(jtypeImport);
+        importCollect?.(jtypeImport);
         return { dataType: info.dataType, jtype, type };
     }
 
-    if (type == "basic" && info.dataType === DataType.ExtensionObject) {
+    if (type === "basic" && info.dataType === DataType.ExtensionObject) {
         const jtypeImport = await referenceExtensionObject(session, dataTypeNodeId);
         const jtype = jtypeImport.name;
-        importCollect && importCollect(jtypeImport);
+        importCollect?.(jtypeImport);
         return { dataType: info.dataType, jtype, type };
     }
     const referenceBasicType = (name: string): string => {
         const t = { name, namespace: -1, module: "BasicType" };
-        importCollect && importCollect(t);
+        importCollect?.(t);
         cache.ensureImported(t);
         return t.name;
     };
-    if (type == "genericNumber") {
-        const { dataTypeCombination } = info;   
+    if (type === "genericNumber") {
+        const { dataTypeCombination } = info;
         return { dataType: DataType.Variant, jtype: "number", type, dataTypeCombination };
     } else {
         const { dataType } = info;
@@ -125,7 +128,7 @@ export async function getCorrespondingJavascriptType(
             case DataType.XmlElement:
                 return { dataType, jtype: referenceBasicType("String"), type };
             default:
-                throw new Error("Unsupported " + dataType + " " + DataType[dataType]);
+                throw new Error(`Unsupported ${dataType} ${DataType[dataType]}`);
         }
     }
 }

package/source/private/to_filename.ts

@@ -1,6 +1,6 @@
 import { snakeCase } from "case-anything";
 
 export function toFilename(str: string): string {
-    str = str.replace(/^DT/,"dt_").replace(/^UA/,"ua_").replace(/^Enum/,"enum_");
+    str = str.replace(/^DT/, "dt_").replace(/^UA/, "ua_").replace(/^Enum/, "enum_");
     return snakeCase(str);
 }

package/source/private/utils.ts

@@ -1,13 +1,14 @@
-import { AttributeIds, BrowseDirection, LocalizedText, NodeClass, NodeClassMask, QualifiedName } from "node-opcua-data-model";
-import { INodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
+import type { ModellingRuleType } from "node-opcua-address-space-base";
 import { DataTypeIds } from "node-opcua-constants";
-import { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
-import { BrowseResult, DataTypeDefinition, ReferenceDescription } from "node-opcua-types";
-import { ModellingRuleType } from "node-opcua-address-space-base";
+import { AttributeIds, BrowseDirection, type LocalizedText, NodeClass, NodeClassMask, QualifiedName } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { type INodeId, type NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
+import type { IBasicSessionBrowseAsyncSimple, IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
+import { type BrowseResult, type DataTypeDefinition, ReferenceDescription } from "node-opcua-types";
 import { DataType } from "node-opcua-variant";
-import { make_debugLog } from "node-opcua-debug";
 
 const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
 
 export async function getDefinition(session: IBasicSessionReadAsyncSimple, nodeId: NodeId): Promise<DataTypeDefinition | null> {
     const dataValue = await session.read({ nodeId, attributeId: AttributeIds.DataTypeDefinition });
@@ -69,7 +70,11 @@ export async function getModellingRule(session: IBasicSessionBrowseAsyncSimple,
     if (!browseResult.references || browseResult.references.length === 0) {
         return null;
     }
-    return browseResult.references[0].browseName.name! as ModellingRuleType;
+    const modellingRuleName = browseResult.references[0].browseName.name;
+    if (!modellingRuleName) {
+        throw new Error(`HasModellingRule reference for ${nodeId.toString()} has no browseName`);
+    }
+    return modellingRuleName as ModellingRuleType;
 }
 export async function isExtensionObject(session: IBasicSessionBrowseAsyncSimple, nodeId: NodeId): Promise<boolean> {
     const n = nodeId as INodeId;
@@ -80,7 +85,10 @@ export async function isExtensionObject(session: IBasicSessionBrowseAsyncSimple,
         return false;
     }
     const r = await getSubtypeNodeIdIfAny(session, nodeId);
-    return await isExtensionObject(session, r!.nodeId);
+    if (!r) {
+        throw new Error(`cannot find SuperType of ${nodeId.toString()}`);
+    }
+    return await isExtensionObject(session, r.nodeId);
 }
 
 export async function isEnumeration(session: IBasicSessionBrowseAsyncSimple, nodeId: NodeId): Promise<boolean> {
@@ -92,7 +100,10 @@ export async function isEnumeration(session: IBasicSessionBrowseAsyncSimple, nod
         return false;
     }
     const r = await getSubtypeNodeIdIfAny(session, nodeId);
-    return await isEnumeration(session, r!.nodeId);
+    if (!r) {
+        throw new Error(`cannot find SuperType of ${nodeId.toString()}`);
+    }
+    return await isEnumeration(session, r.nodeId);
 }
 
 export async function extractBasicDataType(session: IBasicSessionBrowseAsyncSimple, dataTypeNodeId: NodeId): Promise<DataType> {
@@ -101,10 +112,16 @@ export async function extractBasicDataType(session: IBasicSessionBrowseAsyncSimp
         return dataTypeNodeId.value as DataType;
     }
     const r = await getSubtypeNodeIdIfAny(session, dataTypeNodeId);
-    return await extractBasicDataType(session, r!.nodeId);
+    if (!r) {
+        throw new Error(`cannot find SuperType of ${dataTypeNodeId.toString()}`);
+    }
+    return await extractBasicDataType(session, r.nodeId);
 }
 
-export async function getSubtypeNodeIdIfAny(session: IBasicSessionBrowseAsyncSimple, nodeId: NodeId): Promise<ReferenceDescription | null> {
+export async function getSubtypeNodeIdIfAny(
+    session: IBasicSessionBrowseAsyncSimple,
+    nodeId: NodeId
+): Promise<ReferenceDescription | null> {
     if (nodeId.isEmpty()) {
         return null;
     }
@@ -164,7 +181,8 @@ export async function getTypeDefinition(session: IBasicSessionBrowseAsyncSimple,
         resultMask: 0xffff
     });
     if (!browseResult.references || browseResult.references.length === 0) {
-        debugLog("no subtype", nodeId.toString());
+        // c8 ignore next
+        doDebug && debugLog("no subtype", nodeId.toString());
         throw new Error("No subtype");
     }
     return browseResult.references[0];
@@ -212,7 +230,8 @@ export async function _convertNodeIdToDataTypeAsync(
     if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Number) {
         return {
             type: "genericNumber",
-            dataTypeCombination: "DataType.Float | DataType.Double | " +
+            dataTypeCombination:
+                "DataType.Float | DataType.Double | " +
                 "DataType.UInt64 | DataType.UInt32 | DataType.UInt16 |  DataType.SByte | " +
                 "DataType.Int64 | DataType.Int32 | DataType.Int16 | DataType.Byte"
         };
@@ -245,19 +264,22 @@ export async function _convertNodeIdToDataTypeAsync(
         referenceTypeId: resolveNodeId("HasSubtype"),
         resultMask: 0xff
     };
-    // tslint:disable:no-shadowed-variable
     const browseResult = await session.browse(nodeToBrowse);
 
-    const references = browseResult!.references;
+    const references = browseResult?.references;
 
-    if (!references || references.length !== 1) {
-        throw new Error("cannot find SuperType of " + dataTypeName.toString());
+    if (references?.length !== 1) {
+        throw new Error(`cannot find SuperType of ${dataTypeName.toString()}`);
     }
     const nodeId = references[0].nodeId;
 
     const info = await _convertNodeIdToDataTypeAsync(session, nodeId);
-    if (info.type == "enum" && info.enumerationId) {
-        return { ...info, enumerationId: dataTypeId, enumerationType: dataTypeName.name! };
+    if (info.type === "enum" && info.enumerationId) {
+        const enumerationType = dataTypeName.name;
+        if (!enumerationType) {
+            throw new Error(`cannot find name for enumeration dataType ${dataTypeId.toString()}`);
+        }
+        return { ...info, enumerationId: dataTypeId, enumerationType };
     }
     return info;
 }

package/source/private-stuff.ts

@@ -2,5 +2,3 @@ export * from "./index";
 export * from "./options";
 export * from "./private/cache";
 export * from "./private/utils";
-
-

package/source/remove_unused.ts

@@ -9,11 +9,37 @@ import { retryOnTransientWrite } from "./private/fs_retry";
 const dryRun = false;
 
 const NODE_BUILTINS = new Set([
-    "assert", "async_hooks", "buffer", "child_process", "cluster", "console",
-    "crypto", "dgram", "dns", "events", "fs", "http", "http2", "https", "net",
-    "os", "path", "perf_hooks", "process", "querystring", "readline", "stream",
-    "string_decoder", "tls", "tty", "url", "util", "v8", "vm", "worker_threads",
-    "zlib",
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "crypto",
+    "dgram",
+    "dns",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "worker_threads",
+    "zlib"
 ]);
 
 function importGroup(spec: string): number {
@@ -122,7 +148,8 @@ function regroupImports(file: SourceFile) {
     }
 }
 
-const BIOME_IGNORE_EMPTY_INTERFACE = "// biome-ignore lint/suspicious/noEmptyInterface: forward-compatible placeholder for OPC-UA generated types";
+const BIOME_IGNORE_EMPTY_INTERFACE =
+    "// biome-ignore lint/suspicious/noEmptyInterface: forward-compatible placeholder for OPC-UA generated types";
 
 function tidyEmptyInterfaces(file: SourceFile) {
     // Two complaints to resolve:
@@ -152,7 +179,10 @@ function tidyEmptyInterfaces(file: SourceFile) {
         if (iface.getMembers().length !== 0) continue;
         // Rule only fires when there's no extends clause.
         if (iface.getExtends().length !== 0) continue;
-        const leading = iface.getLeadingCommentRanges().map((c) => c.getText()).join("\n");
+        const leading = iface
+            .getLeadingCommentRanges()
+            .map((c) => c.getText())
+            .join("\n");
         if (leading.includes("biome-ignore lint/suspicious/noEmptyInterface")) continue;
         positions.push(iface.getStart());
     }
@@ -232,7 +262,7 @@ export async function cleanUpTypescriptModule(moduleFolder: string) {
     const project = new Project({
         skipAddingFilesFromTsConfig: true,
         skipFileDependencyResolution: true,
-        skipLoadingLibFiles: true,
+        skipLoadingLibFiles: true
     });
 
     const dirFiles = await fs.promises.readdir(sourceFolder);

package/source/update_parent_tsconfig.ts

@@ -1,9 +1,11 @@
 // Purpose of this script is to help ensure that "references" array in packages/tsconfig.json
 // stays up-to-date with nodeset package list.
 
-import { existsSync, promises as fsPromises } from 'fs';
+import { existsSync, promises as fsPromises } from "node:fs";
+
 const { readFile, writeFile } = fsPromises;
-import path from 'path';
+
+import path from "node:path";
 // Uncomment the following to get __dirname equivalent when compiling to ESM
 //import { fileURLToPath } from 'url';
 //const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -11,20 +13,23 @@ import path from 'path';
 import { nodesetCatalog } from "node-opcua-nodesets";
 
 export async function updateParentTSConfig() {
-    const packagesFolder = path.join(__dirname, '..', '..');
-    const parentTSConfigFile = path.join(packagesFolder, 'tsconfig.json');
+    const packagesFolder = path.join(__dirname, "..", "..");
+    const parentTSConfigFile = path.join(packagesFolder, "tsconfig.json");
     console.log(`Updating parent tsconfig.json file: ${parentTSConfigFile}`);
-    const content = await readFile(parentTSConfigFile, 'utf8');
+    const content = await readFile(parentTSConfigFile, "utf8");
     // Strip out comments to avoid JSON parsing error
-    const contentWithoutComments = content.replace(/\/\*.+?\*\//g, '')
-        .replace(/\/\/.+?$/g, '');
+    const contentWithoutComments = content.replace(/\/\*.+?\*\//g, "").replace(/\/\/.+?$/g, "");
     // TODO: Preserve comments automatically
-    let parentTSConfig: any = "";
+    interface TSConfigJson {
+        references: { path: string }[];
+        [key: string]: unknown;
+    }
+    let parentTSConfig: TSConfigJson;
     try {
         parentTSConfig = JSON.parse(contentWithoutComments);
     } catch (err) {
         console.log(`Error parsing JSON from ${parentTSConfigFile}:`, err);
-        console.log('Content without comments:', contentWithoutComments);
+        console.log("Content without comments:", contentWithoutComments);
 
         throw err;
     }
@@ -44,8 +49,12 @@ export async function updateParentTSConfig() {
     }
 
     function compareByPath(a: TSConfigReference, b: TSConfigReference) {
-        if (a.path < b.path) { return -1; }
-        if (a.path > b.path) { return 1; }
+        if (a.path < b.path) {
+            return -1;
+        }
+        if (a.path > b.path) {
+            return 1;
+        }
         return 0;
     }
 
@@ -54,11 +63,13 @@ export async function updateParentTSConfig() {
         parentTSConfig.references.sort(compareByPath);
         // Maintain the compact style `{ "path": "node-opcua-X" }` in references section
         // Also add the comment about Istanbul back
-        const newJSON = JSON.stringify(parentTSConfig, null, "    ")
-            .replace('"removeComments": false', '"removeComments": false /* to prevent Istanbul ignore statements in comments from disappearing */')
-            .replace(/{\s*"path":\s*"([^"]+)"\s*}/g, '{ "path": "$1" }')
-            + '\n';
+        const newJSON = `${JSON.stringify(parentTSConfig, null, "    ")
+            .replace(
+                '"removeComments": false',
+                '"removeComments": false /* to prevent Istanbul ignore statements in comments from disappearing */'
+            )
+            .replace(/{\s*"path":\s*"([^"]+)"\s*}/g, '{ "path": "$1" }')}\n`;
         //console.log('Writing updated tsconfig.json file:', newJSON);
-        await writeFile(parentTSConfigFile, newJSON, 'utf8');
+        await writeFile(parentTSConfigFile, newJSON, "utf8");
     }
 }

package/source/walk_through.ts

@@ -1,6 +1,6 @@
-import { AttributeIds, BrowseDirection, NodeClass, QualifiedName } from "node-opcua-data-model";
-import { ExpandedNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { IBasicSessionAsync } from "node-opcua-pseudo-session";
+import { AttributeIds, BrowseDirection, type NodeClass, type QualifiedName } from "node-opcua-data-model";
+import { type ExpandedNodeId, type NodeId, resolveNodeId } from "node-opcua-nodeid";
+import type { IBasicSessionAsync } from "node-opcua-pseudo-session";
 import { ReferenceDescription } from "node-opcua-types";
 
 export interface ReferenceDescriptionEx extends ReferenceDescription {