componentsjs 5.0.0-beta.2 → 5.0.0-beta.6

package/CHANGELOG.md

@@ -1,6 +1,59 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.0.0-beta.6"></a>
+## [v5.0.0-beta.6](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.5...v5.0.0-beta.6) - 2022-02-09
+
+### Fixed
+* [Fix generic errors still throwing during ignored type checking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c14adcf4757e5194db22c0f0285407bd03bf5635)
+
+<a name="v5.0.0-beta.5"></a>
+## [v5.0.0-beta.5](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.4...v5.0.0-beta.5) - 2022-02-08
+
+### Added
+* [Allow type-checking to be disabled via typeChecking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a55331085e4c5621832e6b23bc52b00068e8256a)
+
+### Changed
+* [Throw error on circular dependencies, Closes #53](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e7a28d1cf87d96d5b58bb6d1f19ce41d6e55aab6)
+
+### Fixed
+* [Fix seeAlso links not handling encoded URI components, Closes #43](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2b72914d2720b2982d4570af55f9b5d7dc196c27)
+
+<a name="v5.0.0-beta.4"></a>
+## [v5.0.0-beta.4](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.3...v5.0.0-beta.4) - 2022-01-29
+
+### Added
+* [Support ParameterRangeIndexed for fixed literals](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0d97782a4a8dcca9fc5bbb3389a4213eca5a5205)
+
+### Changed
+* [Propagate original error messages to require calls, Closes #65](https://github.com/LinkedSoftwareDependencies/Components.js/commit/8934ec9b784def601730b3d3f2e60c4ff0b8776e)
+* [Include config id in invalid param error message](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e724f44e2222eb9917da3b227e2ce0dc9cde15f9)
+* [Update memberKeys to memberFields](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2c7437e1519c1813fb1a29f50d7c20bdbdf7f06e)
+
+<a name="v5.0.0-beta.3"></a>
+## [v5.0.0-beta.3](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.2...v5.0.0-beta.3) - 2022-01-17
+
+### Added
+* [Add support for wildcard parameter ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/83238a9fa08877f29326be562d7d3d5fff860c69)
+* Improve error reporting:
+  * [Add causes for param check failures in error messages](https://github.com/LinkedSoftwareDependencies/Components.js/commit/9be1fd0899ffb8a77ea99e5fb86e661526ef6d1a)
+  * [Improve error message on invalid generic type instantiations](https://github.com/LinkedSoftwareDependencies/Components.js/commit/6ecb9798eeb84f09fece68b3a47454fa8c857ba4)
+  * [Move error context to error state file](https://github.com/LinkedSoftwareDependencies/Components.js/commit/dbf26e072bdc63168814ef4d503777efaf4745eb)
+
+### Fixed
+* Resolve several issues related to generics:
+  * [Throw error on invalid ParameterRangeGenericComponent](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c692ab6175ce466fb32fbe38b973644e2601b2e6)
+  * [Fix generic components not accepting specific types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c7739182fddcb92d46a86fe3e33d6e29fd1134b6)
+  * [Support generic type instantiation during component extension](https://github.com/LinkedSoftwareDependencies/Components.js/commit/98f70e350cc3f9bf8a4ea632db546f74624ddda7)
+  * [Support generic components in params with fixed generics](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d8b30972e1306e9fe9db391d4693aa6000917e60)
+  * [Use GenericComponentExtension to refer to wrapped generic comp extensions](https://github.com/LinkedSoftwareDependencies/Components.js/commit/239895accfdb7f09a7ac8454928bd3e0be5e5f15)
+  * [Fix invalid range display with multiple generics](https://github.com/LinkedSoftwareDependencies/Components.js/commit/b98baf0bcf4546b60299ae548f929693345292bc)
+  * [Handle range merging if left or right is union](https://github.com/LinkedSoftwareDependencies/Components.js/commit/637e140106691b95f0f546cf88eb39f3f80dc61d)
+  * [Handle sub-types when merging param ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/43290525b2e244f5fbb6d5f344760b863329c31b)
+  * [Allow merging of generic component param types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/ee8de7d9b8d18bf6968a17078e493946e5fca8cd)
+  * [Allow param range merging with generic components](https://github.com/LinkedSoftwareDependencies/Components.js/commit/bcea7dcff288ce7068ee244c49c12134208c89da)
+  * [Fix generics crash when doing repeated param type checking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/237572cb8a9c546b098582041ccd7a457b41aecd)
+
 <a name="v5.0.0-beta.2"></a>
 ## [v5.0.0-beta.2](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.1...v5.0.0-beta.2) - 2021-12-09
 

package/README.md

@@ -202,6 +202,57 @@ const myInstance = await manager.instantiate('http://example.org/myInstance');
 [RDF]: https://www.w3.org/RDF/
 [JSON-LD]: https://json-ld.org/
 
+## Advanced usage
+
+The `ComponentsManager` can be customized with the following options:
+
+```javascript
+const manager = await ComponentsManager.build({
+    // Absolute path to the package root from which module resolution should start.
+    mainModulePath: __dirname,
+    // Callback for registering components and modules
+    // Defaults to an invocation of {@link ComponentRegistry.registerAvailableModules}.
+    moduleLoader: (registry) => {},
+    // Callback for registering configurations.
+    // Defaults to no config registrations.
+    configLoader: (registry) => {},
+    // A strategy for constructing instances.
+    // Defaults to {@link ConstructionStrategyCommonJs}.
+    constructionStrategy: new ConstructionStrategyCommonJs(),
+    // If the error state should be dumped into `componentsjs-error-state.json` after failed instantiations.
+    // Defaults to `true`.
+    dumpErrorState: true,
+    // The logging level.
+    // Defaults to `'warn'`.
+    logLevel: 'warn',
+    // The module state.
+    // Defaults to a newly created instance on the {@link mainModulePath}.
+    moduleState: {},
+    // If JSON-LD context validation should be skipped.
+    // Defaults to `true`.
+    skipContextValidation: true,
+    // If values for parameters should be type-checked.
+    // Defaults to `true`.
+    typeChecking: true,
+});
+```
+
+## Cite
+
+If you are using or extending Components.js as part of a scientific publication,
+we would appreciate a citation of our [article](https://linkedsoftwaredependencies.github.io/Article-System-Components/).
+
+```bibtex
+@article{taelman_swj_componentsjs_2022,
+  author = {Taelman, Ruben and Van Herwegen, Joachim and Vander Sande, Miel and Verborgh, Ruben},
+  title = {Components.js: Semantic Dependency Injection},
+  journal = {Semantic Web Journal},
+  year = {2022},
+  month = jan,
+  url = {https://linkedsoftwaredependencies.github.io/Article-System-Components/}
+}
+```
+
 ## License
 Components.js is written by [Ruben Taelman](http://www.rubensworks.net/).
 

package/components/context.jsonld

@@ -2,6 +2,9 @@
   "@context": {
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "type": {
+      "@id": "rdf:type"
+    },
     "types": {
       "@id": "rdf:type"
     },
@@ -29,8 +32,11 @@
     "parameters": {
       "@id": "oo:parameter"
     },
-    "memberKeys": {
-      "@id": "oo:memberKey"
+    "memberFields": {
+      "@id": "oo:memberFields"
+    },
+    "memberFieldName": {
+      "@id": "oo:memberFieldName"
     },
     "genericTypeParameters": {
       "@id": "oo:genericTypeParameter"
@@ -77,6 +83,9 @@
     "ParameterRangeUndefined": {
       "@id": "oo:ParameterRangeUndefined"
     },
+    "ParameterRangeWildcard": {
+      "@id": "oo:ParameterRangeWildcard"
+    },
     "ParameterRangeArray": {
       "@id": "oo:ParameterRangeArray"
     },
@@ -116,6 +125,10 @@
     "ParameterRangeGenericComponent": {
       "@id": "oo:ParameterRangeGenericComponent"
     },
+    "genericTypeInstancesComponentScope": {
+      "@id": "oo:genericTypeInstancesComponentScope",
+      "@type": "@id"
+    },
     "genericTypeInstances": {
       "@id": "oo:genericTypeInstance",
       "@type": "@id"
@@ -131,6 +144,20 @@
       "@id": "oo:parameterRangeGenericBindings",
       "@type": "@id"
     },
+    "GenericComponentExtension": {
+      "@id": "oo:GenericComponentExtension"
+    },
+    "ParameterRangeIndexed": {
+      "@id": "oo:ParameterRangeIndexed"
+    },
+    "parameterRangeIndexedObject": {
+      "@id": "oo:parameterRangeIndexedObject",
+      "@type": "@id"
+    },
+    "parameterRangeIndexedIndex": {
+      "@id": "oo:parameterRangeIndexedIndex",
+      "@type": "@id"
+    },
 
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
     "comment": {

package/lib/ComponentsManager.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentsManager = void 0;
 const fs = require("fs");
 const ComponentsManagerBuilder_1 = require("./loading/ComponentsManagerBuilder");
+const ErrorResourcesContext_1 = require("./util/ErrorResourcesContext");
 /**
  * A components manager can instantiate components.
  * This manager should be created using {@link ComponentsManager.build}.
@@ -51,17 +52,14 @@ class ComponentsManager {
      */
     generateErrorLog(error) {
         if (this.dumpErrorState) {
-            const contents = JSON.stringify({
-                componentTypes: Object.keys(this.componentResources),
-                moduleState: {
+            const contents = JSON.stringify(Object.assign(Object.assign({}, error instanceof ErrorResourcesContext_1.ErrorResourcesContext ? error.exportContext() : {}), { componentTypes: Object.keys(this.componentResources), moduleState: {
                     mainModulePath: this.moduleState.mainModulePath,
                     componentModules: this.moduleState.componentModules,
                     importPaths: this.moduleState.importPaths,
                     contexts: this.moduleState.contexts,
                     nodeModuleImportPaths: this.moduleState.nodeModuleImportPaths,
                     nodeModulePaths: this.moduleState.nodeModulePaths,
-                },
-            }, null, '  ');
+                } }), null, '  ');
             fs.writeFileSync('componentsjs-error-state.json', contents, 'utf8');
             this.logger.error(`Detected fatal error. Generated 'componentsjs-error-state.json' with more information.`);
         }

package/lib/construction/ConfigConstructorPool.js

@@ -28,7 +28,7 @@ class ConfigConstructorPool {
         // if so, return a dummy value, to avoid infinite recursion.
         const resourceBlacklist = settings.resourceBlacklist || {};
         if (resourceBlacklist[configResource.value]) {
-            return Promise.resolve(this.constructionStrategy.createUndefined());
+            return Promise.reject(new ErrorResourcesContext_1.ErrorResourcesContext(`Circular dependency was detected on ${configResource.value}`, { config: configResource }));
         }
         // Before instantiating, first check if the resource is a variable
         if (configResource.isA('Variable')) {

package/lib/construction/strategy/ConstructionStrategyCommonJs.d.ts

@@ -16,7 +16,9 @@ export declare class ConstructionStrategyCommonJs implements IConstructionStrate
      * @param requireName The module name that should be required.
      * @returns {any} The require() result
      */
-    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): void;
+    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): {
+        value: any;
+    } | false;
     createHash(options: ICreationStrategyHashOptions<any>): any;
     createArray(options: ICreationStrategyArrayOptions<any>): any;
     createLazySupplier(options: ICreationStrategySupplierOptions<any>): Promise<any>;

package/lib/construction/strategy/ConstructionStrategyCommonJs.js

@@ -14,16 +14,14 @@ class ConstructionStrategyCommonJs {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
+        // First try requiring current module, and fallback to a plain require
         let object;
-        try {
-            object = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-        }
-        catch (_a) {
-            // Always require relative from main module, because Components.js will in most cases just be dependency.
-            object = this.req(options.requireName.startsWith('.') ?
+        const currentResult = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        object = currentResult !== false ?
+            currentResult.value :
+            this.req(options.requireName.startsWith('.') ?
                 Path.join(process.cwd(), options.requireName) :
                 this.req.resolve(options.requireName, { paths: [options.moduleState.mainModulePath] }));
-        }
         // Determine the child of the require'd element
         let subObject;
         if (options.requireElement) {
@@ -31,7 +29,7 @@ class ConstructionStrategyCommonJs {
             try {
                 subObject = requireElementPath.reduce((acc, subRequireElement) => acc[subRequireElement], object);
             }
-            catch (_b) {
+            catch (_a) {
                 throw new Error(`Failed to get module element ${options.requireElement} from module ${options.requireName}`);
             }
         }
@@ -65,11 +63,11 @@ class ConstructionStrategyCommonJs {
                 const mainPath = Path.posix.join(moduleState.mainModulePath, pckg.main);
                 const required = this.req(mainPath);
                 if (required) {
-                    return required;
+                    return { value: required };
                 }
             }
         }
-        throw new Error('Component is not the main module');
+        return false;
     }
     createHash(options) {
         return options.entries.reduce((data, entry) => {

package/lib/construction/strategy/ConstructionStrategyCommonJsString.js

@@ -30,14 +30,12 @@ class ConstructionStrategyCommonJsString {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
-        let resultingRequirePath;
-        try {
-            this.strategyCommonJs.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-            resultingRequirePath = `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}`;
-        }
-        catch (_a) {
-            resultingRequirePath = options.requireName;
-        }
+        // First try requiring current module, and fallback to a plain require
+        const currentResult = this.strategyCommonJs
+            .requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        const resultingRequirePath = currentResult !== false ?
+            `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}` :
+            options.requireName;
         let serialization = `require('${resultingRequirePath.replace(/\\/gu, '/')}')`;
         // Determine the child of the require'd element
         if (options.requireElement) {

package/lib/loading/ComponentRegistryFinalizer.js

@@ -41,7 +41,13 @@ class ComponentRegistryFinalizer {
      * @param superComponents The components to inherit from.
      */
     inheritParameters(component, superComponents) {
-        for (const superComponent of superComponents) {
+        var _a;
+        for (let superComponent of superComponents) {
+            // Check if the super component is wrapped in a generic component instantiation
+            if (((_a = superComponent.property.type) === null || _a === void 0 ? void 0 : _a.value) === this.objectLoader.contextResolved
+                .expandTerm('oo:GenericComponentExtension')) {
+                superComponent = superComponent.property.component;
+            }
             this.componentRegistry.requireValidComponent(superComponent, component);
             for (const parameter of superComponent.properties.parameters) {
                 if (!component.properties.parameters.includes(parameter)) {

package/lib/loading/ComponentsManagerBuilder.d.ts

@@ -18,6 +18,7 @@ export declare class ComponentsManagerBuilder<Instance = any> {
     private readonly logger;
     private readonly moduleState?;
     private readonly skipContextValidation;
+    private readonly typeChecking;
     constructor(options: IComponentsManagerBuilderOptions<Instance>);
     static createLogger(logLevel?: LogLevel): Logger;
     static createObjectLoader(): RdfObjectLoader;
@@ -69,4 +70,9 @@ export interface IComponentsManagerBuilderOptions<Instance> {
      * Defaults to `true`.
      */
     skipContextValidation?: boolean;
+    /**
+     * If values for parameters should be type-checked.
+     * Defaults to `true`.
+     */
+    typeChecking?: boolean;
 }

package/lib/loading/ComponentsManagerBuilder.js

@@ -31,6 +31,9 @@ class ComponentsManagerBuilder {
         this.skipContextValidation = options.skipContextValidation === undefined ?
             true :
             Boolean(options.skipContextValidation);
+        this.typeChecking = options.typeChecking === undefined ?
+            true :
+            Boolean(options.typeChecking);
     }
     static createLogger(logLevel = 'warn') {
         return (0, winston_1.createLogger)({
@@ -92,7 +95,7 @@ class ComponentsManagerBuilder {
         this.logger.info(`Loaded configs`);
         // Build constructor pool
         const runTypeConfigs = {};
-        const parameterHandler = new ParameterHandler_1.ParameterHandler({ objectLoader });
+        const parameterHandler = new ParameterHandler_1.ParameterHandler({ objectLoader, typeChecking: this.typeChecking });
         const configConstructorPool = new ConfigConstructorPool_1.ConfigConstructorPool({
             objectLoader,
             configPreprocessors: [

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -89,20 +89,19 @@ class ConfigPreprocessorComponent {
         return configRaw;
     }
     createGenericsContext(handleResponse, config) {
+        // Create a new generics context for the component's generic type parameters
         const genericsContext = new GenericsContext_1.GenericsContext(this.objectLoader, handleResponse.component.properties.genericTypeParameters);
-        // Populate with manually defined generic type bindings
-        const genericTypesInner = handleResponse.component.properties.genericTypeParameters;
-        if (genericTypesInner.length < config.properties.genericTypeInstances.length) {
-            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid generic type instantiations: more generic types are passed than are defined on the component.`, {
-                config,
-                component: handleResponse.component,
-            });
-        }
-        for (const [i, genericTypeInstance] of config.properties.genericTypeInstances.entries()) {
-            // Remap generic type IRI to inner generic type IRI
-            const genericTypeIdInner = genericTypesInner[i].value;
-            genericsContext.bindings[genericTypeIdInner] = genericTypeInstance.properties.parameterRangeGenericBindings;
-            genericsContext.genericTypeIds[genericTypeIdInner] = true;
+        // If the config has a genericTypeInstancesComponentScope, it will also have genericTypeInstances.
+        // In that case, we bind these instances to the component's generic type parameters within the context.
+        // (these values may have been set during generic param type-checking in
+        // ParameterPropertyHandlerRange#hasParamValueValidType)
+        if (config.property.genericTypeInstancesComponentScope &&
+            handleResponse.component.value === config.property.genericTypeInstancesComponentScope.value) {
+            const conflict = genericsContext.bindComponentGenericTypes(handleResponse.component, config.properties.genericTypeInstances, { config }, (subType, superType) => this.parameterHandler.parameterPropertyHandlerRange
+                .hasType(subType, superType, genericsContext, config.property.genericTypeInstancesComponentScope, config.properties.genericTypeInstances, { config }));
+            if (conflict) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(conflict.description, conflict.context);
+            }
         }
         return genericsContext;
     }

package/lib/preprocess/GenericsContext.d.ts

@@ -1,30 +1,74 @@
+import type * as RDF from '@rdfjs/types';
 import type { Resource, RdfObjectLoader } from 'rdf-object';
+import type { IParamValueConflict } from './parameterproperty/ParameterPropertyHandlerRange';
 /**
  * Context for binding generic types to a concrete range value.
  */
 export declare class GenericsContext {
+    private static readonly XSD_INHERITANCE_TABLE;
     private readonly objectLoader;
     /**
      * Set of generic type ids.
      * @private
      */
-    readonly genericTypeIds: Record<string, boolean>;
+    genericTypeIds: Record<string, boolean>;
     /**
      * Mapping of generic type id to the resolved range.
      * @private
      */
-    readonly bindings: Record<string, Resource[]>;
+    bindings: Record<string, Resource>;
     constructor(objectLoader: RdfObjectLoader, genericTypeParameters: Resource[]);
     /**
      * Try to to bind the given value to the given generic.
      * @param genericTypeId IRI of the generic to bind.
      * @param value The value to bind to.
-     * @param typeValidator Callback for validating values against types.
+     * @param valueTypeValidator Callback for validating values against types.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
      */
-    bindGenericTypeToValue(genericTypeId: string, value: Resource | undefined, typeValidator: (subValue: Resource | undefined, subType: Resource) => boolean): boolean;
+    bindGenericTypeToValue(genericTypeId: string, value: Resource | undefined, valueTypeValidator: (subValue: Resource | undefined, subType: Resource) => IParamValueConflict | undefined, typeTypeValidator: (subValue: Resource, subType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
+    /**
+     * Try to bind the given range to the given generic.
+     * @param genericTypeId IRI of the generic to bind.
+     * @param range The range to bind to.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
+     */
+    bindGenericTypeToRange(genericTypeId: string, range: Resource, typeTypeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
     /**
      * Infer the parameter range of the given value.
      * @param value A value.
      */
-    inferValueRange(value: Resource | undefined): Resource[];
+    inferValueRange(value: Resource | undefined): Resource | undefined;
+    /**
+     * Merge the given ranges into a new range.
+     * This will return undefined in the ranges are incompatible.
+     *
+     * If one type is more specific than the other, it will return the narrowest type.
+     *
+     * @param rangeA A first range.
+     * @param rangeB A second range.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     */
+    mergeRanges(rangeA: Resource, rangeB: Resource, typeTypeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): Resource | undefined;
+    protected mergeUnion(rangeUnion: Resource, rangeOther: Resource, typeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): Resource | undefined;
+    /**
+     * Check if the given type is a subtype of the given super type.
+     * @param type A type node.
+     * @param potentialSuperType A potential super type node.
+     */
+    isXsdSubType(type: RDF.Term, potentialSuperType: RDF.Term): boolean;
+    /**
+     * Apply the give generic type instances for the given component's generic type parameters.
+     *
+     * This will throw if the number of passed instances does not match with
+     * the number of generic type parameters on the component.
+     *
+     * @param component The component
+     * @param genericTypeInstances The generic type instances to apply.
+     * @param errorContext The context for error reporting.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean False if the application failed due to a binding error. True otherwise
+     */
+    bindComponentGenericTypes(component: Resource, genericTypeInstances: Resource[], errorContext: Record<string, Resource | Resource[] | string>, typeTypeValidator: (subValue: Resource, subType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
 }