@redocly/openapi-core 1.0.0-beta.100

package/lib/rules/common/operation-security-defined.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OperationSecurityDefined: Oas3Rule | Oas2Rule;

package/lib/rules/common/operation-security-defined.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationSecurityDefined = void 0;
+const OperationSecurityDefined = () => {
+    let referencedSchemes = new Map();
+    return {
+        DefinitionRoot: {
+            leave(_, { report }) {
+                for (const [name, scheme] of referencedSchemes.entries()) {
+                    if (scheme.defined)
+                        continue;
+                    for (const reportedFromLocation of scheme.from) {
+                        report({
+                            message: `There is no \`${name}\` security scheme defined.`,
+                            location: reportedFromLocation.key(),
+                        });
+                    }
+                }
+            },
+        },
+        SecurityScheme(_securityScheme, { key }) {
+            referencedSchemes.set(key.toString(), { defined: true, from: [] });
+        },
+        SecurityRequirement(requirements, { location }) {
+            for (const requirement of Object.keys(requirements)) {
+                const authScheme = referencedSchemes.get(requirement);
+                const requirementLocation = location.child([requirement]);
+                if (!authScheme) {
+                    referencedSchemes.set(requirement, { from: [requirementLocation] });
+                }
+                else {
+                    authScheme.from.push(requirementLocation);
+                }
+            }
+        },
+    };
+};
+exports.OperationSecurityDefined = OperationSecurityDefined;

package/lib/rules/common/operation-singular-tag.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OperationSingularTag: Oas3Rule | Oas2Rule;

package/lib/rules/common/operation-singular-tag.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationSingularTag = void 0;
+const OperationSingularTag = () => {
+    return {
+        Operation(operation, { report, location }) {
+            if (operation.tags && operation.tags.length > 1) {
+                report({
+                    message: 'Operation `tags` object should have only one tag.',
+                    location: location.child(['tags']).key(),
+                });
+            }
+        },
+    };
+};
+exports.OperationSingularTag = OperationSingularTag;

package/lib/rules/common/operation-summary.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OperationSummary: Oas3Rule | Oas2Rule;

package/lib/rules/common/operation-summary.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationSummary = void 0;
+const utils_1 = require("../utils");
+const OperationSummary = () => {
+    return {
+        Operation(operation, ctx) {
+            utils_1.validateDefinedAndNonEmpty('summary', operation, ctx);
+        },
+    };
+};
+exports.OperationSummary = OperationSummary;

package/lib/rules/common/operation-tag-defined.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OperationTagDefined: Oas3Rule | Oas2Rule;

package/lib/rules/common/operation-tag-defined.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationTagDefined = void 0;
+const OperationTagDefined = () => {
+    let definedTags;
+    return {
+        DefinitionRoot(root) {
+            var _a;
+            definedTags = new Set(((_a = root.tags) !== null && _a !== void 0 ? _a : []).map((t) => t.name));
+        },
+        Operation(operation, { report, location }) {
+            if (operation.tags) {
+                for (let i = 0; i < operation.tags.length; i++) {
+                    if (!definedTags.has(operation.tags[i])) {
+                        report({
+                            message: `Operation tags should be defined in global tags.`,
+                            location: location.child(['tags', i]),
+                        });
+                    }
+                }
+            }
+        },
+    };
+};
+exports.OperationTagDefined = OperationTagDefined;

package/lib/rules/common/parameter-description.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const ParameterDescription: Oas3Rule | Oas2Rule;

package/lib/rules/common/parameter-description.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterDescription = void 0;
+const ParameterDescription = () => {
+    return {
+        Parameter(parameter, { report, location }) {
+            if (parameter.description === undefined) {
+                report({
+                    message: 'Parameter object description must be present.',
+                    location: { reportOnKey: true },
+                });
+            }
+            else if (!parameter.description) {
+                report({
+                    message: 'Parameter object description must be non-empty string.',
+                    location: location.child(['description']),
+                });
+            }
+        },
+    };
+};
+exports.ParameterDescription = ParameterDescription;

package/lib/rules/common/path-declaration-must-exist.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathDeclarationMustExist: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-declaration-must-exist.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathDeclarationMustExist = void 0;
+const PathDeclarationMustExist = () => {
+    return {
+        PathItem(_path, { report, key }) {
+            if (key.indexOf('{}') !== -1) {
+                report({
+                    message: 'Path parameter declarations must be non-empty. `{}` is invalid.',
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.PathDeclarationMustExist = PathDeclarationMustExist;

package/lib/rules/common/path-excludes-patterns.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const PathExcludesPatterns: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-excludes-patterns.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathExcludesPatterns = void 0;
+const PathExcludesPatterns = ({ patterns }) => {
+    return {
+        PathItem(_path, { report, key, location }) {
+            if (!patterns)
+                throw new Error(`Parameter "patterns" is not provided for "path-excludes-patterns" rule`);
+            const pathKey = key.toString();
+            if (pathKey.startsWith('/')) {
+                const matches = patterns.filter((pattern) => pathKey.match(pattern));
+                for (const match of matches) {
+                    report({
+                        message: `path \`${pathKey}\` should not match regex pattern: \`${match}\``,
+                        location: location.key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.PathExcludesPatterns = PathExcludesPatterns;

package/lib/rules/common/path-http-verbs-order.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathHttpVerbsOrder: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-http-verbs-order.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathHttpVerbsOrder = void 0;
+const defaultOrder = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+const PathHttpVerbsOrder = (opts) => {
+    const order = (opts && opts.order) || defaultOrder;
+    if (!Array.isArray(order)) {
+        throw new Error('path-http-verbs-order `order` option must be an array');
+    }
+    return {
+        PathItem(path, { report, location }) {
+            const httpVerbs = Object.keys(path).filter((k) => order.includes(k));
+            for (let i = 0; i < httpVerbs.length - 1; i++) {
+                const aIdx = order.indexOf(httpVerbs[i]);
+                const bIdx = order.indexOf(httpVerbs[i + 1]);
+                if (bIdx < aIdx) {
+                    report({
+                        message: 'Operation http verbs must be ordered.',
+                        location: Object.assign({ reportOnKey: true }, location.child(httpVerbs[i + 1])),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.PathHttpVerbsOrder = PathHttpVerbsOrder;

package/lib/rules/common/path-not-include-query.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathNotIncludeQuery: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-not-include-query.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathNotIncludeQuery = void 0;
+const PathNotIncludeQuery = () => {
+    return {
+        PathMap: {
+            PathItem(_operation, { report, key }) {
+                if (key.toString().includes('?')) {
+                    report({
+                        message: `Don't put query string items in the path, they belong in parameters with \`in: query\`.`,
+                        location: { reportOnKey: true },
+                    });
+                }
+            },
+        }
+    };
+};
+exports.PathNotIncludeQuery = PathNotIncludeQuery;

package/lib/rules/common/path-params-defined.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathParamsDefined: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-params-defined.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathParamsDefined = void 0;
+const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
+const PathParamsDefined = () => {
+    let pathTemplateParams;
+    let definedPathParams;
+    let currentPath;
+    return {
+        PathItem: {
+            enter(_, { key }) {
+                definedPathParams = new Set();
+                currentPath = key;
+                pathTemplateParams = new Set(Array.from(key.toString().matchAll(pathRegex)).map((m) => m[1]));
+            },
+            Parameter(parameter, { report, location }) {
+                if (parameter.in === 'path' && parameter.name) {
+                    definedPathParams.add(parameter.name);
+                    if (!pathTemplateParams.has(parameter.name)) {
+                        report({
+                            message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+                            location: location.child(['name']),
+                        });
+                    }
+                }
+            },
+            Operation: {
+                leave(_op, { report, location }) {
+                    for (const templateParam of Array.from(pathTemplateParams.keys())) {
+                        if (!definedPathParams.has(templateParam)) {
+                            report({
+                                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${currentPath}\`.`,
+                                location: location.child(['parameters']).key(), // report on operation
+                            });
+                        }
+                    }
+                },
+                Parameter(parameter, { report, location }) {
+                    if (parameter.in === 'path' && parameter.name) {
+                        definedPathParams.add(parameter.name);
+                        if (!pathTemplateParams.has(parameter.name)) {
+                            report({
+                                message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+                                location: location.child(['name']),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.PathParamsDefined = PathParamsDefined;

package/lib/rules/common/path-segment-plural.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathSegmentPlural: Oas3Rule | Oas2Rule;

package/lib/rules/common/path-segment-plural.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathSegmentPlural = void 0;
+const utils_1 = require("../../utils");
+const PathSegmentPlural = (opts) => {
+    const { ignoreLastPathSegment, exceptions } = opts;
+    return {
+        PathItem: {
+            leave(_path, { report, key, location }) {
+                const pathKey = key.toString();
+                if (pathKey.startsWith('/')) {
+                    const pathSegments = pathKey.split('/');
+                    pathSegments.shift();
+                    if (ignoreLastPathSegment && pathSegments.length > 1) {
+                        pathSegments.pop();
+                    }
+                    for (const pathSegment of pathSegments) {
+                        if (exceptions && exceptions.includes(pathSegment))
+                            continue;
+                        if (!utils_1.isPathParameter(pathSegment) && utils_1.isSingular(pathSegment)) {
+                            report({
+                                message: `path segment \`${pathSegment}\` should be plural.`,
+                                location: location.key(),
+                            });
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.PathSegmentPlural = PathSegmentPlural;

package/lib/rules/common/paths-kebab-case.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathsKebabCase: Oas3Rule | Oas2Rule;

package/lib/rules/common/paths-kebab-case.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathsKebabCase = void 0;
+const PathsKebabCase = () => {
+    return {
+        PathItem(_path, { report, key }) {
+            const segments = key.substr(1).split('/').filter(s => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${key}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.PathsKebabCase = PathsKebabCase;

package/lib/rules/common/response-contains-header.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const ResponseContainsHeader: Oas3Rule | Oas2Rule;

package/lib/rules/common/response-contains-header.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsHeader = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsHeader = (options) => {
+    const names = options.names || {};
+    return {
+        Operation: {
+            Response: {
+                enter: (response, { report, location, key }) => {
+                    var _a;
+                    const expectedHeaders = names[key] ||
+                        names[utils_1.getMatchingStatusCodeRange(key)] ||
+                        names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                        [];
+                    for (const expectedHeader of expectedHeaders) {
+                        if (!((_a = response.headers) === null || _a === void 0 ? void 0 : _a[expectedHeader])) {
+                            report({
+                                message: `Response object must contain a "${expectedHeader}" header.`,
+                                location: location.child('headers').key(),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsHeader = ResponseContainsHeader;

package/lib/rules/common/scalar-property-missing-example.d.ts

@@ -0,0 +1,2 @@
+import type { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const ScalarPropertyMissingExample: Oas3Rule | Oas2Rule;

package/lib/rules/common/scalar-property-missing-example.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarPropertyMissingExample = void 0;
+const oas_types_1 = require("../../oas-types");
+const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
+const ScalarPropertyMissingExample = () => {
+    return {
+        SchemaProperties(properties, { report, location, oasVersion, resolve }) {
+            for (const propName of Object.keys(properties)) {
+                const propSchema = resolve(properties[propName]).node;
+                if (!propSchema || !isScalarSchema(propSchema)) {
+                    continue;
+                }
+                if (propSchema.example === undefined &&
+                    propSchema.examples === undefined) {
+                    report({
+                        message: `Scalar property should have "example"${oasVersion === oas_types_1.OasVersion.Version3_1 ? ' or "examples"' : ''} defined.`,
+                        location: location.child(propName).key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.ScalarPropertyMissingExample = ScalarPropertyMissingExample;
+function isScalarSchema(schema) {
+    if (!schema.type) {
+        return false;
+    }
+    if (schema.allOf || schema.anyOf || schema.oneOf) {
+        // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
+        // We need core support for checking contrstrains through those keywords.
+        return false;
+    }
+    if (schema.format === 'binary') {
+        return false;
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.every((t) => SCALAR_TYPES.includes(t));
+    }
+    return SCALAR_TYPES.includes(schema.type);
+}

package/lib/rules/common/spec.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OasSpec: Oas3Rule | Oas2Rule;

package/lib/rules/common/spec.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OasSpec = void 0;
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+const ref_utils_1 = require("../../ref-utils");
+const utils_2 = require("../../utils");
+const OasSpec = () => {
+    return {
+        any(node, { report, type, location, key, resolve, ignoreNextVisitorsOnNode }) {
+            var _a, _b, _c, _d;
+            const nodeType = utils_1.oasTypeOf(node);
+            if (type.items) {
+                if (nodeType !== 'array') {
+                    report({
+                        message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
+                    });
+                    ignoreNextVisitorsOnNode();
+                }
+                return;
+            }
+            else if (nodeType !== 'object') {
+                report({
+                    message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
+                });
+                ignoreNextVisitorsOnNode();
+                return;
+            }
+            const required = typeof type.required === 'function' ? type.required(node, key) : type.required;
+            for (let propName of required || []) {
+                if (!node.hasOwnProperty(propName)) {
+                    report({
+                        message: `The field \`${propName}\` must be present on this level.`,
+                        location: [{ reportOnKey: true }],
+                    });
+                }
+            }
+            const allowed = (_a = type.allowed) === null || _a === void 0 ? void 0 : _a.call(type, node);
+            if (allowed && utils_2.isPlainObject(node)) {
+                for (const propName in node) {
+                    if (allowed.includes(propName) ||
+                        (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
+                        !Object.keys(type.properties).includes(propName)) {
+                        continue;
+                    }
+                    report({
+                        message: `The field \`${propName}\` is not allowed here.`,
+                        location: location.child([propName]).key()
+                    });
+                }
+            }
+            const requiredOneOf = type.requiredOneOf || null;
+            if (requiredOneOf) {
+                let hasProperty = false;
+                for (let propName of requiredOneOf || []) {
+                    if (node.hasOwnProperty(propName)) {
+                        hasProperty = true;
+                    }
+                }
+                if (!hasProperty)
+                    report({
+                        message: `Must contain at least one of the following fields: ${(_b = type.requiredOneOf) === null || _b === void 0 ? void 0 : _b.join(', ')}.`,
+                        location: [{ reportOnKey: true }],
+                    });
+            }
+            for (const propName of Object.keys(node)) {
+                const propLocation = location.child([propName]);
+                let propValue = node[propName];
+                let propType = type.properties[propName];
+                if (propType === undefined)
+                    propType = type.additionalProperties;
+                if (typeof propType === 'function')
+                    propType = propType(propValue, propName);
+                if (types_1.isNamedType(propType)) {
+                    continue; // do nothing for named schema, it is executed with the next any call
+                }
+                const propSchema = propType;
+                const propValueType = utils_1.oasTypeOf(propValue);
+                if (propSchema === undefined) {
+                    if (propName.startsWith('x-'))
+                        continue;
+                    report({
+                        message: `Property \`${propName}\` is not expected here.`,
+                        suggest: utils_1.getSuggest(propName, Object.keys(type.properties)),
+                        location: propLocation.key(),
+                    });
+                    continue;
+                }
+                if (propSchema === null) {
+                    continue; // just defined, no validation
+                }
+                if (propSchema.resolvable !== false && ref_utils_1.isRef(propValue)) {
+                    propValue = resolve(propValue).node;
+                }
+                if (propSchema.enum) {
+                    if (!propSchema.enum.includes(propValue)) {
+                        report({
+                            location: propLocation,
+                            message: `\`${propName}\` can be one of the following only: ${propSchema.enum
+                                .map((i) => `"${i}"`)
+                                .join(', ')}.`,
+                            suggest: utils_1.getSuggest(propValue, propSchema.enum),
+                        });
+                    }
+                }
+                else if (propSchema.type && !utils_1.matchesJsonSchemaType(propValue, propSchema.type, false)) {
+                    report({
+                        message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
+                        location: propLocation,
+                    });
+                }
+                else if (propValueType === 'array' && ((_c = propSchema.items) === null || _c === void 0 ? void 0 : _c.type)) {
+                    const itemsType = (_d = propSchema.items) === null || _d === void 0 ? void 0 : _d.type;
+                    for (let i = 0; i < propValue.length; i++) {
+                        const item = propValue[i];
+                        if (!utils_1.matchesJsonSchemaType(item, itemsType, false)) {
+                            report({
+                                message: `Expected type \`${itemsType}\` but got \`${utils_1.oasTypeOf(item)}\`.`,
+                                location: propLocation.child([i]),
+                            });
+                        }
+                    }
+                }
+                if (typeof propSchema.minimum === 'number') {
+                    if (propSchema.minimum > node[propName]) {
+                        report({
+                            message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
+                            location: location.child([propName]),
+                        });
+                    }
+                }
+            }
+        },
+    };
+};
+exports.OasSpec = OasSpec;

package/lib/rules/common/tag-description.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const TagDescription: Oas3Rule | Oas2Rule;

package/lib/rules/common/tag-description.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagDescription = void 0;
+const utils_1 = require("../utils");
+const TagDescription = () => {
+    return {
+        Tag(tag, ctx) {
+            utils_1.validateDefinedAndNonEmpty('description', tag, ctx);
+        },
+    };
+};
+exports.TagDescription = TagDescription;

package/lib/rules/common/tags-alphabetical.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const TagsAlphabetical: Oas3Rule | Oas2Rule;

package/lib/rules/common/tags-alphabetical.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagsAlphabetical = void 0;
+const TagsAlphabetical = () => {
+    return {
+        DefinitionRoot(root, { report, location }) {
+            if (!root.tags)
+                return;
+            for (let i = 0; i < root.tags.length - 1; i++) {
+                if (root.tags[i].name > root.tags[i + 1].name) {
+                    report({
+                        message: 'The `tags` array should be in alphabetical order.',
+                        location: location.child(['tags', i]),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.TagsAlphabetical = TagsAlphabetical;

package/lib/rules/no-unresolved-refs.d.ts

@@ -0,0 +1,5 @@
+import { Oas3Rule } from '../visitors';
+import { ResolveResult, Problem } from '../walk';
+import { Location } from '../ref-utils';
+export declare const NoUnresolvedRefs: Oas3Rule;
+export declare function reportUnresolvedRef(resolved: ResolveResult<any>, report: (m: Problem) => void, location: Location): void;