node-opcua-factory 2.71.0 → 2.73.1

package/source/{factories_builtin_types_special.ts → builtin_types_special.ts}

@@ -5,8 +5,8 @@
 import { assert } from "node-opcua-assert";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
 
-import { registerType } from "./factories_builtin_types";
-import { ConstructorFunc } from "./constructor_type";
+import { registerType } from "./builtin_types";
+import { ConstructorFunc } from "./types";
 
 function _self_encode(constructor: any) {
     assert(typeof constructor === "function");

package/source/datatype_factory.ts

@@ -7,17 +7,38 @@ import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+import { DataTypeIds } from "node-opcua-constants";
 
-import { ConstructorFunc, ConstructorFuncWithSchema } from "./constructor_type";
-import { BaseUAObject } from "./factories_baseobject";
-import { getBuildInType, hasBuiltInType } from "./factories_builtin_types";
-import { EnumerationDefinitionSchema, getEnumeration, hasEnumeration } from "./factories_enumerations";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-import { BasicTypeDefinition } from "./types";
+import { getBuiltInType as getBuiltInType, hasBuiltInType } from "./builtin_types";
+import { EnumerationDefinitionSchema, getBuiltInEnumeration, hasBuiltInEnumeration } from "./enumerations";
+import {
+    CommonInterface,
+    StructuredTypeField,
+    IStructuredTypeSchema,
+    ConstructorFuncWithSchema,
+    ConstructorFunc,
+    IBaseUAObject
+} from "./types";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
+export function _findFieldSchema(typeDictionary: DataTypeFactory, field: StructuredTypeField, value: any): IStructuredTypeSchema {
+    const fieldType = field.fieldType;
+
+    if (field.allowSubType && field.category === "complex") {
+        const fieldTypeConstructor = value ? value.constructor : field.fieldTypeConstructor;
+
+        const _newFieldSchema = fieldTypeConstructor.schema;
+
+        return _newFieldSchema as IStructuredTypeSchema;
+    }
+
+    const fieldTypeConstructor = field.fieldTypeConstructor || typeDictionary.getStructureTypeConstructor(fieldType);
+
+    return (field.schema as IStructuredTypeSchema) || (fieldTypeConstructor as any).schema;
+}
+
 export class DataTypeFactory {
     public defaultByteOrder: string;
     public targetNamespace: string;
@@ -27,7 +48,6 @@ export class DataTypeFactory {
     private _structureTypeConstructorByDataTypeMap: Map<string, ConstructorFuncWithSchema> = new Map();
     private _structureTypeConstructorByEncodingNodeIdMap: Map<string, any> = new Map();
     private _enumerations: Map<string, EnumerationDefinitionSchema> = new Map();
-    private _simpleTypes: Map<string, { nodeId: NodeId; definition: BasicTypeDefinition }> = new Map();
 
     private baseDataFactories: DataTypeFactory[];
 
@@ -40,46 +60,23 @@ export class DataTypeFactory {
     public repairBaseDataFactories(baseDataFactories: DataTypeFactory[]): void {
         this.baseDataFactories = baseDataFactories;
     }
-    // -----------------------------
-    public registerSimpleType(name: string, dataTypeNodeId: NodeId, def: BasicTypeDefinition): void {
-        // istanbul ignore next
-        if (this._simpleTypes.has(name)) {
-            throw new Error("registerSimpleType " + name + " already register");
-        }
-        this._simpleTypes.set(name, { nodeId: dataTypeNodeId, definition: def });
-    }
 
-    public hasSimpleType(name: string): boolean {
-        if (this._simpleTypes.has(name)) {
-            return true;
-        }
-        for (const factory of this.baseDataFactories) {
-            if (factory.hasSimpleType(name)) {
-                return true;
-            }
-        }
-        const hasSimpleT = hasBuiltInType(name);
-        if (hasSimpleT) {
-            return hasSimpleT;
-        }
+    public hasBuiltInType(name: string): boolean {
         return hasBuiltInType(name);
     }
-    public getSimpleType(name: string): BasicTypeDefinition {
-        if (this._simpleTypes.has(name)) {
-            return this._simpleTypes.get(name)!.definition;
-        }
-        for (const factory of this.baseDataFactories) {
-            if (factory.hasSimpleType(name)) {
-                return factory.getSimpleType(name);
-            }
-        }
-        return getBuildInType(name);
+
+    public getBuiltInType(name: string): CommonInterface {
+        return getBuiltInType(name);
     }
+
+    public getBuiltInTypeByDataType(nodeId: NodeId): CommonInterface {
+        return getBuiltInType(DataTypeIds[nodeId.value as number]);
+    }
+
     // -----------------------------
     // EnumerationDefinitionSchema
     public registerEnumeration(enumeration: EnumerationDefinitionSchema): void {
-        debugLog("Registering Enumeration ", enumeration.name);
-        assert(!this._enumerations.has(enumeration.name));
+        assert(!this._enumerations.has(enumeration.name), "enumeration already registered");
         this._enumerations.set(enumeration.name, enumeration);
     }
 
@@ -93,11 +90,12 @@ export class DataTypeFactory {
                 return true;
             }
         }
-        if (hasEnumeration(enumName)) {
+        if (hasBuiltInEnumeration(enumName)) {
             return true;
         }
         return false;
     }
+
     public getEnumeration(enumName: string): EnumerationDefinitionSchema | null {
         if (this._enumerations.has(enumName)) {
             return this._enumerations.get(enumName) || null;
@@ -109,7 +107,7 @@ export class DataTypeFactory {
                 return e;
             }
         }
-        const ee = getEnumeration(enumName);
+        const ee = getBuiltInEnumeration(enumName);
         return ee;
     }
     //  ----------------------------
@@ -178,7 +176,7 @@ export class DataTypeFactory {
         return false;
     }
 
-    public getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
+    public getStructuredTypeSchema(typeName: string): IStructuredTypeSchema {
         const constructor = this.getStructureTypeConstructor(typeName);
         return constructor.schema;
     }
@@ -245,7 +243,7 @@ export class DataTypeFactory {
         return false;
     }
 
-    public constructObject(binaryEncodingNodeId: NodeId): BaseUAObject {
+    public constructObject(binaryEncodingNodeId: NodeId): IBaseUAObject {
         if (!verifyExpandedNodeId(binaryEncodingNodeId)) {
             throw new Error(" constructObject : invalid expandedNodeId provided " + binaryEncodingNodeId.toString());
         }
@@ -253,8 +251,7 @@ export class DataTypeFactory {
 
         if (!constructor) {
             debugLog("Cannot find constructor for " + binaryEncodingNodeId.toString());
-            return new BaseUAObject();
-            // throw new Error("Cannot find constructor for " + expandedNodeId.toString());
+            throw new Error("Cannot find constructor for " + binaryEncodingNodeId.toString());
         }
         return new constructor();
     }
@@ -315,7 +312,7 @@ export class DataTypeFactory {
     }
 }
 
-function dumpSchema(schema: StructuredTypeSchema, write: any) {
+function dumpSchema(schema: IStructuredTypeSchema, write: any) {
     write("name           ", schema.name);
     write("dataType       ", schema.dataTypeNodeId.toString());
     write("binaryEncoding ", schema.encodingDefaultBinary!.toString());

package/source/encode_decode.ts

@@ -0,0 +1,37 @@
+import assert from "node-opcua-assert";
+import { OutputBinaryStream, BinaryStream } from "node-opcua-binary-stream";
+
+export function defaultEncode(value: any, stream: OutputBinaryStream): void {
+    /** */
+}
+
+export function defaultDecode(stream: BinaryStream): any {
+    return null;
+}
+
+export function defaultGuidValue(): any {
+    return Buffer.alloc(0);
+}
+
+export function toJSONGuid(value: any): any {
+    if (typeof value === "string") {
+        return value;
+    }
+    assert(value instanceof Buffer);
+    return value.toString("base64");
+}
+
+export function encodeAny(value: any, stream: OutputBinaryStream) {
+    assert(false, "type 'Any' cannot be encoded");
+}
+
+export function decodeAny(stream: BinaryStream) {
+    assert(false, "type 'Any' cannot be decoded");
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function encodeNull(value: any, stream: OutputBinaryStream): void {}
+
+export function decodeNull(stream: BinaryStream): any {
+    return null;
+}

package/source/{factories_enumerations.ts → enumerations.ts}

@@ -5,7 +5,8 @@ import { assert } from "node-opcua-assert";
 
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
 import { Enum, EnumItem, _TypescriptEnum , adaptTypescriptEnum} from "node-opcua-enum";
-import { EnumerationDefinition, TypeSchemaBase, TypeSchemaConstructorOptions } from "./types";
+import { TypeSchemaBase } from "./builtin_types";
+import { EnumerationDefinition, TypeSchemaConstructorOptions } from "./types";
 
 function _encode_enumeration(typedEnum: Enum, value: number, stream: OutputBinaryStream): void {
     assert(typeof value === "number", "Expecting a number here");
@@ -88,13 +89,14 @@ export function registerEnumeration(options: EnumerationDefinitionOptions): Enum
     return enumerationDefinition.typedEnum;
 }
 
-export function hasEnumeration(enumerationName: string): boolean {
+export function hasBuiltInEnumeration(enumerationName: string): boolean {
     return _enumerations.has(enumerationName);
 }
 
-export function getEnumeration(enumerationName: string): EnumerationDefinitionSchema {
-    if (!exports.hasEnumeration(enumerationName)) {
+export function getBuiltInEnumeration(enumerationName: string): EnumerationDefinitionSchema {
+    if (!hasBuiltInEnumeration(enumerationName)) {
         throw new Error("Cannot find enumeration with type " + enumerationName);
     }
     return _enumerations.get(enumerationName) as EnumerationDefinitionSchema;
 }
+

package/source/{factories_factories.ts → get_standard_data_type_factory.ts}

@@ -1,24 +1,14 @@
 /**
  * @module node-opcua-factory
  */
-// tslint:disable:no-console
-
-import * as chalk from "chalk";
-
-import { assert } from "node-opcua-assert";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
 
 import { DataTypeFactory } from "./datatype_factory";
-import { ConstructorFuncWithSchema, ConstructorFunc } from "./constructor_type";
-
-import { BaseUAObject } from "./factories_baseobject";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
+import { ConstructorFunc, ConstructorFuncWithSchema } from "./types";
 
 let globalFactory: DataTypeFactory;
+
 export function getStandardDataTypeFactory(): DataTypeFactory {
     if (!globalFactory) {
         globalFactory = new DataTypeFactory([]);
@@ -26,32 +16,24 @@ export function getStandardDataTypeFactory(): DataTypeFactory {
     }
     return globalFactory;
 }
+
 export function getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
     return getStandardDataTypeFactory().getStructureTypeConstructor(typeName);
 }
+
 export function hasStructuredType(typeName: string): boolean {
     return getStandardDataTypeFactory().hasStructuredType(typeName);
 }
-export function getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
-    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
-}
 
 export function getConstructor(binaryEncodingNodeId: ExpandedNodeId): ConstructorFunc | null {
     return getStandardDataTypeFactory().getConstructor(binaryEncodingNodeId);
 }
+
 export function hasConstructor(binaryEncodingNodeId: ExpandedNodeId): boolean {
     return getStandardDataTypeFactory().hasConstructor(binaryEncodingNodeId);
 }
-export function constructObject(binaryEncodingNodeId: ExpandedNodeId): BaseUAObject {
-    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
-}
-export function registerClassDefinition(
-    dataTypeNodeId: NodeId,
-    className: string,
-    classConstructor: ConstructorFuncWithSchema
-): void {
-    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
-}
+
+
 /* istanbul ignore next */
 export function dump(): void {
     getStandardDataTypeFactory().dump();

package/source/get_structured_type_schema.ts

@@ -0,0 +1,10 @@
+import { ExpandedNodeId } from "node-opcua-nodeid";
+import { getStandardDataTypeFactory } from "./get_standard_data_type_factory";
+import { IBaseUAObject, IStructuredTypeSchema } from "./types";
+
+export function getStructuredTypeSchema(typeName: string): IStructuredTypeSchema {
+    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
+}
+export function constructObject(binaryEncodingNodeId: ExpandedNodeId): IBaseUAObject {
+    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
+}

package/source/index.ts

@@ -1,15 +1,18 @@
 /**
  * @module node-opcua-factory
  */
-export * from "./constructor_type";
+export * from "./base_ua_object";
+export * from "./basic_type";
+export * from "./builtin_types_special";
+export * from "./builtin_types";
 export * from "./datatype_factory";
-export * from "./factories_id_generator";
-export * from "./factories_enumerations";
-export * from "./factories_basic_type";
-export * from "./factories_builtin_types";
-export * from "./factories_builtin_types_special";
-export * from "./factories_baseobject";
-export * from "./types";
-export * from "./factories_schema_helpers";
-export * from "./factories_factories";
-export * from "./factories_structuredTypeSchema";
+export * from "./enumerations";
+export * from "./get_standard_data_type_factory";
+export * from "./get_structured_type_schema";
+export * from "./id_generator";
+export * from "./nodeid_type";
+export * from "./parameters";
+export * from "./register_class_definition";
+export * from "./schema_helpers";
+export * from "./structured_type_schema";
+export * from "./types";

package/source/nodeid_type.ts

@@ -0,0 +1,17 @@
+import { registerEnumeration } from "./enumerations";
+
+
+
+export enum NodeIdType {
+    ReferenceType = 0x01,
+    IsForward = 0x02,
+    NodeClass = 0x04,
+    BrowseName = 0x08,
+    DisplayName = 0x10,
+    TypeDefinition = 0x20
+}
+export const schemaNodeIdType = {
+    name: "NodeIdType",
+    enumValues: NodeIdType
+};
+export const _enumerationNodeIdType = registerEnumeration(schemaNodeIdType);

package/source/parameters.ts

@@ -0,0 +1,3 @@
+export const parameters = {
+    debugSchemaHelper: typeof process === "object" && !!process.env.DEBUG_CLASS
+};

package/source/register_class_definition.ts

@@ -0,0 +1,11 @@
+import { NodeId } from "node-opcua-nodeid";
+import { getStandardDataTypeFactory } from "./get_standard_data_type_factory";
+import { ConstructorFuncWithSchema } from "./types";
+
+export function registerClassDefinition(
+    dataTypeNodeId: NodeId,
+    className: string,
+    classConstructor: ConstructorFuncWithSchema
+): void {
+    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
+}

package/source/{factories_schema_helpers.ts → schema_helpers.ts}

@@ -3,14 +3,13 @@
  */
 import { assert } from "node-opcua-assert";
 import { make_debugLog } from "node-opcua-debug";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-import { CommonInterface, FieldCategory, FieldType, StructuredTypeField } from "./types";
+import { DataTypeIds } from "node-opcua-constants";
+import { DataTypeFactory } from "./datatype_factory";
+import { BaseUAObject } from "./base_ua_object";
+import { FieldCategory, FieldType, IStructuredTypeSchema, StructuredTypeField } from "./types";
 
 const debugLog = make_debugLog(__filename);
 
-export const parameters = {
-    debugSchemaHelper: (typeof process === "object" && !!process.env.DEBUG_CLASS)
-};
 
 /**
  * ensure correctness of a schema object.
@@ -19,20 +18,27 @@ export const parameters = {
  * @param schema
  *
  */
-export function check_schema_correctness(schema: StructuredTypeSchema): void {
+export function check_schema_correctness(schema: IStructuredTypeSchema): void {
     assert(typeof schema.name === "string", " expecting schema to have a name");
     assert(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
     assert(schema.baseType === undefined || typeof schema.baseType === "string");
 }
 
+
 /**
  * @method initialize_value
  * @param value
  * @param defaultValue
  * @return {*}
  */
-export function initialize_field(field: StructuredTypeField, value: unknown): any {
+export function initialize_field(field: StructuredTypeField, value: unknown, factory?: DataTypeFactory): any {
     const _t = field.schema;
+
+    if (field.allowSubType && field.category === "complex") {
+        if (value instanceof BaseUAObject) {
+            value = { dataType: DataTypeIds.Structure, value };
+        }
+    }
     if (!(_t !== null && typeof _t === "object")) {
         throw new Error(
             "initialize_field: expecting field.schema to be set field.name = '" + field.name + "' type = " + field.fieldType
@@ -71,21 +77,6 @@ export function initialize_field(field: StructuredTypeField, value: unknown): an
     return value;
 }
 
-function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (defaultValue === null) {
-        if (value === null) {
-            return null;
-        }
-    }
-    if (_t.coerce) {
-        value = _t.coerce(value);
-        return value;
-    }
-    return value;
-}
 /**
  * @method initialize_field_array
  * @param field
@@ -93,7 +84,7 @@ function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
  * @return
  */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function initialize_field_array(field: FieldType, valueArray: any): any {
+export function initialize_field_array(field: FieldType, valueArray: any, factory?: DataTypeFactory): any {
     const _t = field.schema;
 
     let value;
@@ -104,24 +95,11 @@ export function initialize_field_array(field: FieldType, valueArray: any): any {
     if (!valueArray && field.defaultValue === null) {
         return null;
     }
-
     valueArray = valueArray || [];
-
-    let defaultValue: any;
-    if (_t.computer_default_value) {
-        defaultValue = _t.computer_default_value(field.defaultValue);
-    }
     const arr: unknown[] = [];
     for (i = 0; i < valueArray.length; i++) {
-        value = initialize_value(valueArray[i], defaultValue, _t);
+        value = initialize_field(field, valueArray[i], factory);
         arr.push(value);
     }
-    if (field.validate) {
-        for (i = 0; i < arr.length; i++) {
-            if (!field.validate(arr[i])) {
-                throw Error(" invalid value " + arr[i] + " for field " + field.name + " of type " + field.fieldType);
-            }
-        }
-    }
     return arr;
 }

package/source/{factories_structuredTypeSchema.ts → structured_type_schema.ts}

@@ -8,13 +8,19 @@ import { BinaryStream } from "node-opcua-binary-stream";
 import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
 import { lowerFirstLetter } from "node-opcua-utils";
 
-import { getBuildInType, hasBuiltInType } from "./factories_builtin_types";
-import { getEnumeration, hasEnumeration } from "./factories_enumerations";
-import { getStructuredTypeSchema, getStructureTypeConstructor, hasStructuredType } from "./factories_factories";
-import { parameters } from "./factories_schema_helpers";
-import { DataTypeFactory } from "./datatype_factory";
-import { CommonInterface, FieldCategory, FieldInterfaceOptions, FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
-import { BaseUAObject } from "./factories_baseobject";
+import { getBuiltInType, hasBuiltInType, TypeSchemaBase } from "./builtin_types";
+import { getBuiltInEnumeration, hasBuiltInEnumeration } from "./enumerations";
+import { parameters } from "./parameters";
+import { getStructureTypeConstructor, hasStructuredType } from "./get_standard_data_type_factory";
+import { getStructuredTypeSchema } from "./get_structured_type_schema";
+import {
+    CommonInterface,
+    FieldCategory,
+    FieldInterfaceOptions,
+    FieldType,
+    IStructuredTypeSchema,
+    StructuredTypeOptions
+} from "./types";
 
 function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
     const fieldType = field.fieldType;
@@ -23,7 +29,7 @@ function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
         return field.category;
     }
 
-    if (hasEnumeration(fieldType)) {
+    if (hasBuiltInEnumeration(fieldType)) {
         return FieldCategory.enumeration;
     } else if (hasBuiltInType(fieldType)) {
         return FieldCategory.basic;
@@ -65,12 +71,12 @@ function figureOutSchema(
                 returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
             } else {
                 // LocalizedText etc ...
-                returnValue = getBuildInType(fieldTypeWithoutNS);
+                returnValue = getBuiltInType(fieldTypeWithoutNS);
             }
             break;
         case FieldCategory.basic:
-            returnValue = getBuildInType(fieldTypeWithoutNS);
-            if(!returnValue) {
+            returnValue = getBuiltInType(fieldTypeWithoutNS);
+            if (!returnValue) {
                 returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
                 if (returnValue) {
                     console.log("Why ?");
@@ -78,14 +84,13 @@ function figureOutSchema(
             }
             break;
         case FieldCategory.enumeration:
-            returnValue = getEnumeration(fieldTypeWithoutNS);
+            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
             break;
     }
     if (null === returnValue || undefined === returnValue) {
         try {
-            returnValue = getEnumeration(fieldTypeWithoutNS);
-        }
-        catch(err){
+            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
+        } catch (err) {
             console.log(err);
         }
         throw new Error(
@@ -119,32 +124,32 @@ function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: Fiel
         );
     }
 
+    const { defaultValue, isArray, documentation, fieldType, switchBit, switchValue, allowSubType, dataType, basicDataType } =
+        fieldLight;
     return {
         name: lowerFirstLetter(fieldLight.name),
-
+        originalName: fieldLight.name,
         category,
-        defaultValue: fieldLight.defaultValue,
-        isArray: fieldLight.isArray,
-
-        documentation: fieldLight.documentation,
-        fieldType: fieldLight.fieldType,
-
-        switchBit: fieldLight.switchBit,
-
-        switchValue: fieldLight.switchValue,
-
+        defaultValue,
+        isArray,
+        documentation,
+        fieldType,
+        switchBit,
+        switchValue,
+        allowSubType,
+        dataType,
+        basicDataType,
         schema
     };
 }
-
-export class StructuredTypeSchema extends TypeSchemaBase {
+export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredTypeSchema {
     public fields: FieldType[];
     public id: NodeId;
     public dataTypeNodeId: NodeId;
 
     public baseType: string;
     public _possibleFields: string[];
-    public _baseSchema: StructuredTypeSchema | null;
+    public _baseSchema: IStructuredTypeSchema | null;
 
     public documentation?: string;
 
@@ -211,7 +216,7 @@ export class StructuredTypeSchema extends TypeSchemaBase {
  * @return {*}
  *
  */
-export function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSchema | null {
+export function get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeSchema | null {
     let baseSchema = schema._baseSchema;
     if (baseSchema) {
         return baseSchema;
@@ -248,7 +253,7 @@ export function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSch
  * (by walking up the inheritance chain)
  *
  */
-export function extract_all_fields(schema: StructuredTypeSchema): string[] {
+export function extract_all_fields(schema: IStructuredTypeSchema): string[] {
     // returns cached result if any
     // istanbul ignore next
     if (schema._possibleFields) {
@@ -276,7 +281,7 @@ export function extract_all_fields(schema: StructuredTypeSchema): string[] {
  * @method  check_options_correctness_against_schema
  *
  */
-export function check_options_correctness_against_schema(obj: any, schema: StructuredTypeSchema, options: any): boolean {
+export function check_options_correctness_against_schema(obj: any, schema: IStructuredTypeSchema, options: any): boolean {
     if (!parameters.debugSchemaHelper) {
         return true; // ignoring set
     }
@@ -330,10 +335,6 @@ export function check_options_correctness_against_schema(obj: any, schema: Struc
     return true;
 }
 
-export function buildStructuredType2(dataTypeFactory: DataTypeFactory, schemaLight: StructuredTypeOptions): StructuredTypeSchema {
-    return new StructuredTypeSchema(schemaLight);
-}
-
 export function buildStructuredType(schemaLight: StructuredTypeOptions): StructuredTypeSchema {
     return new StructuredTypeSchema(schemaLight);
 }