@redocly/openapi-core 1.0.0-beta.99 → 1.0.0-rc.2

package/lib/redocly/registry-api.js

@@ -30,8 +30,14 @@ class RegistryApi {
         return this;
     }
     request(path = '', options = {}, region) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
+            const currentCommand = typeof process !== 'undefined' ? ((_a = process.env) === null || _a === void 0 ? void 0 : _a.REDOCLY_CLI_COMMAND) || '' : '';
+            const redoclyEnv = typeof process !== 'undefined' ? ((_b = process.env) === null || _b === void 0 ? void 0 : _b.REDOCLY_ENVIRONMENT) || '' : '';
+            const headers = Object.assign({}, options.headers || {}, {
+                'x-redocly-cli-version': version,
+                'user-agent': `redocly-cli / ${version} ${currentCommand} ${redoclyEnv}`,
+            });
             if (!headers.hasOwnProperty('authorization')) {
                 throw new Error('Unauthorized');
             }
@@ -80,7 +86,7 @@ class RegistryApi {
             throw new Error('Could not prepare file upload');
         });
     }
-    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, }) {
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.request(`/${organizationId}/${name}/${version}`, {
                 method: 'PUT',
@@ -94,6 +100,8 @@ class RegistryApi {
                     branch,
                     isUpsert,
                     isPublic,
+                    batchId,
+                    batchSize,
                 }),
             }, this.region);
             if (response.ok) {

package/lib/ref-utils.d.ts

@@ -23,3 +23,4 @@ export declare function pointerBaseName(pointer: string): string;
 export declare function refBaseName(ref: string): string;
 export declare function isAbsoluteUrl(ref: string): boolean;
 export declare function isMappingRef(mapping: string): boolean;
+export declare function isAnchor(ref: string): boolean;

package/lib/ref-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
+exports.isAnchor = exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
+const utils_1 = require("./utils");
 function joinPointer(base, key) {
     if (base === '')
         base = '#/';
@@ -41,7 +42,7 @@ function parseRef(ref) {
     const [uri, pointer] = ref.split('#/');
     return {
         uri: uri || null,
-        pointer: pointer ? pointer.split('/').map(unescapePointer).filter(Boolean) : [],
+        pointer: pointer ? pointer.split('/').map(unescapePointer).filter(utils_1.isTruthy) : [],
     };
 }
 exports.parseRef = parseRef;
@@ -73,3 +74,7 @@ function isMappingRef(mapping) {
         mapping.indexOf('/') > -1);
 }
 exports.isMappingRef = isMappingRef;
+function isAnchor(ref) {
+    return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
+}
+exports.isAnchor = isAnchor;

package/lib/resolve.d.ts

@@ -33,7 +33,7 @@ export declare function makeDocumentFromString(sourceString: string, absoluteRef
     parsed: unknown;
 };
 export declare class BaseResolver {
-    private config;
+    protected config: ResolveConfig;
     cache: Map<string, Promise<Document | ResolveError>>;
     constructor(config?: ResolveConfig);
     getFiles(): Set<string>;

package/lib/resolve.js

@@ -110,10 +110,16 @@ class BaseResolver {
                     return new Source(absoluteRef, body, mimeType);
                 }
                 else {
-                    return new Source(absoluteRef, yield fs.promises.readFile(absoluteRef, 'utf-8'));
+                    if (fs.lstatSync(absoluteRef).isDirectory()) {
+                        throw new Error(`Expected a file but received a folder at ${absoluteRef}`);
+                    }
+                    const content = yield fs.promises.readFile(absoluteRef, 'utf-8');
+                    // In some cases file have \r\n line delimeters like on windows, we should skip it.
+                    return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
                 }
             }
             catch (error) {
+                error.message = error.message.replace(', lstat', '');
                 throw new ResolveError(error);
             }
         });
@@ -184,6 +190,7 @@ function resolveDocument(opts) {
         return resolvedRefMap;
         function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
             const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+            const anchorRefsMap = new Map();
             walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
             function walk(node, type, nodeAbsoluteRef) {
                 if (typeof node !== 'object' || node === null) {
@@ -194,10 +201,14 @@ function resolveDocument(opts) {
                     return;
                 }
                 seedNodes.add(nodeId);
+                const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+                if (anchor) {
+                    anchorRefsMap.set(`#${anchor}`, node);
+                }
                 if (Array.isArray(node)) {
                     const itemsType = type.items;
                     // we continue resolving unknown types, but stop early on known scalars
-                    if (type !== unknownType && itemsType === undefined) {
+                    if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                         return;
                     }
                     for (let i = 0; i < node.length; i++) {
@@ -214,6 +225,11 @@ function resolveDocument(opts) {
                         propType = propType(propValue, propName);
                     if (propType === undefined)
                         propType = unknownType;
+                    if (type.extensionsPrefix &&
+                        propName.startsWith(type.extensionsPrefix) &&
+                        propType === unknownType) {
+                        propType = types_1.SpecExtension;
+                    }
                     if (!types_1.isNamedType(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
                         propType = propType.directResolveAs;
                         propValue = { $ref: propValue };
@@ -243,6 +259,20 @@ function resolveDocument(opts) {
                     if (hasRef(refStack.prev, ref)) {
                         throw new Error('Self-referencing circular pointer');
                     }
+                    if (ref_utils_1.isAnchor(ref.$ref)) {
+                        // Wait for all anchors in the document to be collected firstly.
+                        yield utils_1.nextTick();
+                        const resolvedRef = {
+                            resolved: true,
+                            isRemote: false,
+                            node: anchorRefsMap.get(ref.$ref),
+                            document,
+                            nodePointer: ref.$ref,
+                        };
+                        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                        resolvedRefMap.set(refId, resolvedRef);
+                        return resolvedRef;
+                    }
                     const { uri, pointer } = ref_utils_1.parseRef(ref.$ref);
                     const isRemote = uri !== null;
                     let targetDoc;
@@ -271,7 +301,7 @@ function resolveDocument(opts) {
                     };
                     let target = targetDoc.parsed;
                     const segments = pointer;
-                    for (let segment of segments) {
+                    for (const segment of segments) {
                         if (typeof target !== 'object') {
                             target = undefined;
                             break;

package/lib/rules/ajv.d.ts

@@ -1,8 +1,8 @@
-import { ErrorObject } from '@redocly/ajv';
+import { ErrorObject } from '@redocly/ajv/dist/2020';
 import { Location } from '../ref-utils';
 import { ResolveFn } from '../walk';
 export declare function releaseAjvInstance(): void;
-export declare function validateJsonSchema(data: any, schema: any, schemaLoc: Location, instancePath: string, resolve: ResolveFn<any>, disallowAdditionalProperties: boolean): {
+export declare function validateJsonSchema(data: any, schema: any, schemaLoc: Location, instancePath: string, resolve: ResolveFn, allowAdditionalProperties: boolean): {
     valid: boolean;
     errors: (ErrorObject & {
         suggest?: string[];

package/lib/rules/ajv.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateJsonSchema = exports.releaseAjvInstance = void 0;
-const ajv_1 = require("@redocly/ajv");
+const _2020_1 = require("@redocly/ajv/dist/2020");
 const ref_utils_1 = require("../ref-utils");
 let ajvInstance = null;
 function releaseAjvInstance() {
     ajvInstance = null;
 }
 exports.releaseAjvInstance = releaseAjvInstance;
-function getAjv(resolve, disallowAdditionalProperties) {
+function getAjv(resolve, allowAdditionalProperties) {
     if (!ajvInstance) {
-        ajvInstance = new ajv_1.default({
+        ajvInstance = new _2020_1.default({
             schemaId: '$id',
             meta: true,
             allErrors: true,
@@ -20,11 +20,11 @@ function getAjv(resolve, disallowAdditionalProperties) {
             discriminator: true,
             allowUnionTypes: true,
             validateFormats: false,
-            defaultAdditionalProperties: !disallowAdditionalProperties,
+            defaultUnevaluatedProperties: allowAdditionalProperties,
             loadSchemaSync(base, $ref) {
                 const resolvedRef = resolve({ $ref }, base.split('#')[0]);
                 if (!resolvedRef || !resolvedRef.location)
-                    return undefined;
+                    return false;
                 return Object.assign({ $id: resolvedRef.location.absolutePointer }, resolvedRef.node);
             },
             logger: false,
@@ -32,15 +32,15 @@ function getAjv(resolve, disallowAdditionalProperties) {
     }
     return ajvInstance;
 }
-function getAjvValidator(schema, loc, resolve, disallowAdditionalProperties) {
-    const ajv = getAjv(resolve, disallowAdditionalProperties);
+function getAjvValidator(schema, loc, resolve, allowAdditionalProperties) {
+    const ajv = getAjv(resolve, allowAdditionalProperties);
     if (!ajv.getSchema(loc.absolutePointer)) {
         ajv.addSchema(Object.assign({ $id: loc.absolutePointer }, schema), loc.absolutePointer);
     }
     return ajv.getSchema(loc.absolutePointer);
 }
-function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, disallowAdditionalProperties) {
-    const validate = getAjvValidator(schema, schemaLoc, resolve, disallowAdditionalProperties);
+function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allowAdditionalProperties) {
+    const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
     if (!validate)
         return { valid: true, errors: [] }; // unresolved refs are reported
     const valid = validate(data, {
@@ -56,7 +56,7 @@ function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, disa
     };
     function beatifyErrorMessage(error) {
         let message = error.message;
-        let suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
+        const suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
         if (suggest) {
             message += ` ${suggest.map((e) => `"${e}"`).join(', ')}`;
         }
@@ -68,8 +68,8 @@ function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, disa
         if (propName) {
             message = `\`${propName}\` property ${message}`;
         }
-        if (error.keyword === 'additionalProperties') {
-            const property = error.params.additionalProperty;
+        if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+            const property = error.params.additionalProperty || error.params.unevaluatedProperty;
             message = `${message} \`${property}\``;
             error.instancePath += '/' + ref_utils_1.escapePointer(property);
         }

package/lib/rules/common/assertions/asserts.d.ts

@@ -1,5 +1,30 @@
-declare type Asserts = Record<string, (value: any, condition: any) => boolean>;
-export declare const runOnKeysSet: Set<string>;
-export declare const runOnValuesSet: Set<string>;
+import { AssertionContext, AssertResult, CustomFunction } from 'core/src/config/types';
+import { Location } from '../../../ref-utils';
+export declare type AssertionFnContext = AssertionContext & {
+    baseLocation: Location;
+    rawValue?: any;
+};
+export declare type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
+export declare type Asserts = {
+    pattern: AssertionFn;
+    notPattern: AssertionFn;
+    enum: AssertionFn;
+    defined: AssertionFn;
+    required: AssertionFn;
+    disallowed: AssertionFn;
+    undefined: AssertionFn;
+    nonEmpty: AssertionFn;
+    minLength: AssertionFn;
+    maxLength: AssertionFn;
+    casing: AssertionFn;
+    sortOrder: AssertionFn;
+    mutuallyExclusive: AssertionFn;
+    mutuallyRequired: AssertionFn;
+    requireAny: AssertionFn;
+    ref: AssertionFn;
+    const: AssertionFn;
+};
+export declare const runOnKeysSet: Set<keyof Asserts>;
+export declare const runOnValuesSet: Set<keyof Asserts>;
 export declare const asserts: Asserts;
-export {};
+export declare function buildAssertCustomFunction(fn: CustomFunction): AssertionFn;

package/lib/rules/common/assertions/asserts.js

@@ -1,21 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
-const utils_1 = require("./utils");
+exports.buildAssertCustomFunction = exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
+const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
 exports.runOnKeysSet = new Set([
     'mutuallyExclusive',
     'mutuallyRequired',
     'enum',
     'pattern',
+    'notPattern',
     'minLength',
     'maxLength',
     'casing',
     'sortOrder',
     'disallowed',
     'required',
+    'requireAny',
+    'ref',
+    'const',
+    'defined', // In case if `property` for assertions is not added
 ]);
 exports.runOnValuesSet = new Set([
     'pattern',
+    'notPattern',
     'enum',
     'defined',
     'undefined',
@@ -24,120 +31,243 @@ exports.runOnValuesSet = new Set([
     'maxLength',
     'casing',
     'sortOrder',
+    'ref',
+    'const',
 ]);
 exports.asserts = {
-    pattern: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        const values = typeof value === 'string' ? [value] : value;
-        const regexOptions = condition.match(/(\b\/\b)(.+)/g) || ['/'];
-        condition = condition.slice(1).replace(regexOptions[0], '');
-        const regx = new RegExp(condition, regexOptions[0].slice(1));
-        for (let _val of values) {
-            if (!_val.match(regx)) {
-                return false;
-            }
-        }
-        return true;
+    pattern: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = utils_2.regexFromString(condition);
+        return values
+            .map((_val) => !(regex === null || regex === void 0 ? void 0 : regex.test(_val)) && {
+            message: `"${_val}" should match a regex ${condition}`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
     },
-    enum: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        const values = typeof value === 'string' ? [value] : value;
-        for (let _val of values) {
-            if (!condition.includes(_val)) {
-                return false;
-            }
-        }
-        return true;
+    notPattern: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = utils_2.regexFromString(condition);
+        return values
+            .map((_val) => (regex === null || regex === void 0 ? void 0 : regex.test(_val)) && {
+            message: `"${_val}" should not match a regex ${condition}`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    enum: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => !condition.includes(_val) && {
+            message: `"${_val}" should be one of the predefined values`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
-    defined: (value, condition = true) => {
+    defined: (value, condition = true, { baseLocation }) => {
         const isDefined = typeof value !== 'undefined';
-        return condition ? isDefined : !isDefined;
+        const isValid = condition ? isDefined : !isDefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should be defined` : 'Should be not defined',
+                    location: baseLocation,
+                },
+            ];
     },
-    required: (value, keys) => {
-        for (const requiredKey of keys) {
-            if (!value.includes(requiredKey)) {
-                return false;
-            }
-        }
-        return true;
+    required: (value, keys, { baseLocation }) => {
+        return keys
+            .map((requiredKey) => !value.includes(requiredKey) && {
+            message: `${requiredKey} is required`,
+            location: baseLocation.key(),
+        })
+            .filter(utils_1.isTruthy);
+    },
+    disallowed: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => condition.includes(_val) && {
+            message: `"${_val}" is disallowed`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
-    disallowed: (value, condition) => {
+    const: (value, condition, { baseLocation }) => {
         if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        const values = typeof value === 'string' ? [value] : value;
-        for (let _val of values) {
-            if (condition.includes(_val)) {
-                return false;
-            }
+            return [];
+        if (Array.isArray(value)) {
+            return value
+                .map((_val) => condition !== _val && {
+                message: `"${_val}" should be equal ${condition} `,
+                location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            })
+                .filter(utils_1.isTruthy);
+        }
+        else {
+            return value !== condition
+                ? [
+                    {
+                        message: `${value} should be equal ${condition}`,
+                        location: baseLocation,
+                    },
+                ]
+                : [];
         }
-        return true;
     },
-    undefined: (value, condition = true) => {
+    undefined: (value, condition = true, { baseLocation }) => {
         const isUndefined = typeof value === 'undefined';
-        return condition ? isUndefined : !isUndefined;
+        const isValid = condition ? isUndefined : !isUndefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be defined` : 'Should be defined',
+                    location: baseLocation,
+                },
+            ];
     },
-    nonEmpty: (value, condition = true) => {
+    nonEmpty: (value, condition = true, { baseLocation }) => {
         const isEmpty = typeof value === 'undefined' || value === null || value === '';
-        return condition ? !isEmpty : isEmpty;
+        const isValid = condition ? !isEmpty : isEmpty;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be empty` : 'Should be empty',
+                    location: baseLocation,
+                },
+            ];
     },
-    minLength: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        return value.length >= condition;
+    minLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length >= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at least ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
     },
-    maxLength: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        return value.length <= condition;
+    maxLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length <= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at most ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
     },
-    casing: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true; // property doesn't exist, no need to lint it with this assert
-        const values = typeof value === 'string' ? [value] : value;
-        for (let _val of values) {
-            let matchCase = false;
-            switch (condition) {
-                case 'camelCase':
-                    matchCase = !!_val.match(/^[a-z][a-zA-Z0-9]+$/g);
-                    break;
-                case 'kebab-case':
-                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g);
-                    break;
-                case 'snake_case':
-                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g);
-                    break;
-                case 'PascalCase':
-                    matchCase = !!_val.match(/^[A-Z][a-zA-Z0-9]+$/g);
-                    break;
-                case 'MACRO_CASE':
-                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g);
-                    break;
-                case 'COBOL-CASE':
-                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g);
-                    break;
-                case 'flatcase':
-                    matchCase = !!_val.match(/^[a-z][a-z0-9]+$/g);
-                    break;
-            }
-            if (!matchCase) {
-                return false;
-            }
-        }
-        return true;
+    casing: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const casingRegexes = {
+            camelCase: /^[a-z][a-zA-Z0-9]+$/g,
+            'kebab-case': /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g,
+            snake_case: /^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g,
+            PascalCase: /^[A-Z][a-zA-Z0-9]+$/g,
+            MACRO_CASE: /^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g,
+            'COBOL-CASE': /^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g,
+            flatcase: /^[a-z][a-z0-9]+$/g,
+        };
+        return values
+            .map((_val) => !_val.match(casingRegexes[condition]) && {
+            message: `"${_val}" should use ${condition}`,
+            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(utils_1.isTruthy);
     },
-    sortOrder: (value, condition) => {
-        if (typeof value === 'undefined')
-            return true;
-        return utils_1.isOrdered(value, condition);
+    sortOrder: (value, condition, { baseLocation }) => {
+        const direction = condition.direction || condition;
+        const property = condition.property;
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && !property) {
+            return [
+                {
+                    message: `Please define a property to sort objects by`,
+                    location: baseLocation,
+                },
+            ];
+        }
+        if (typeof value === 'undefined' || utils_2.isOrdered(value, condition))
+            return [];
+        return [
+            {
+                message: `Should be sorted in ${direction === 'asc' ? 'an ascending' : 'a descending'} order${property ? ` by property ${property}` : ''}`,
+                location: baseLocation,
+            },
+        ];
     },
-    mutuallyExclusive: (value, condition) => {
-        return utils_1.getIntersectionLength(value, condition) < 2;
+    mutuallyExclusive: (value, condition, { baseLocation }) => {
+        if (utils_2.getIntersectionLength(value, condition) < 2)
+            return [];
+        return [
+            {
+                message: `${condition.join(', ')} keys should be mutually exclusive`,
+                location: baseLocation.key(),
+            },
+        ];
     },
-    mutuallyRequired: (value, condition) => {
-        return utils_1.getIntersectionLength(value, condition) > 0
-            ? utils_1.getIntersectionLength(value, condition) === condition.length
+    mutuallyRequired: (value, condition, { baseLocation }) => {
+        const isValid = utils_2.getIntersectionLength(value, condition) > 0
+            ? utils_2.getIntersectionLength(value, condition) === condition.length
             : true;
+        return isValid
+            ? []
+            : [
+                {
+                    message: `Properties ${condition.join(', ')} are mutually required`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    requireAny: (value, condition, { baseLocation }) => {
+        return utils_2.getIntersectionLength(value, condition) >= 1
+            ? []
+            : [
+                {
+                    message: `Should have any of ${condition.join(', ')}`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    ref: (_value, condition, { baseLocation, rawValue }) => {
+        if (typeof rawValue === 'undefined')
+            return []; // property doesn't exist, no need to lint it with this assert
+        const hasRef = rawValue.hasOwnProperty('$ref');
+        if (typeof condition === 'boolean') {
+            const isValid = condition ? hasRef : !hasRef;
+            return isValid
+                ? []
+                : [
+                    {
+                        message: condition ? `should use $ref` : 'should not use $ref',
+                        location: hasRef ? baseLocation : baseLocation.key(),
+                    },
+                ];
+        }
+        const regex = utils_2.regexFromString(condition);
+        const isValid = hasRef && (regex === null || regex === void 0 ? void 0 : regex.test(rawValue['$ref']));
+        return isValid
+            ? []
+            : [
+                {
+                    message: `$ref value should match ${condition}`,
+                    location: hasRef ? baseLocation : baseLocation.key(),
+                },
+            ];
     },
 };
+function buildAssertCustomFunction(fn) {
+    return (value, options, ctx) => fn.call(null, value, options, ctx);
+}
+exports.buildAssertCustomFunction = buildAssertCustomFunction;