@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/rules/common/no-ambiguous-paths.d.ts

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

package/lib/rules/common/no-ambiguous-paths.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoAmbiguousPaths = void 0;
+const NoAmbiguousPaths = () => {
+    return {
+        Paths(pathMap, { report, location }) {
+            const seenPaths = [];
+            for (const currentPath of Object.keys(pathMap)) {
+                const ambiguousPath = seenPaths.find((seenPath) => arePathsAmbiguous(seenPath, currentPath));
+                if (ambiguousPath) {
+                    report({
+                        message: `Paths should resolve unambiguously. Found two ambiguous paths: \`${ambiguousPath}\` and \`${currentPath}\`.`,
+                        location: location.child([currentPath]).key(),
+                    });
+                }
+                seenPaths.push(currentPath);
+            }
+        },
+    };
+};
+exports.NoAmbiguousPaths = NoAmbiguousPaths;
+function arePathsAmbiguous(a, b) {
+    const partsA = a.split('/');
+    const partsB = b.split('/');
+    if (partsA.length !== partsB.length)
+        return false;
+    let aVars = 0;
+    let bVars = 0;
+    let ambiguous = true;
+    for (let i = 0; i < partsA.length; i++) {
+        const aIsVar = partsA[i].match(/^{.+?}$/);
+        const bIsVar = partsB[i].match(/^{.+?}$/);
+        if (aIsVar || bIsVar) {
+            if (aIsVar)
+                aVars++;
+            if (bIsVar)
+                bVars++;
+            continue;
+        }
+        else if (partsA[i] !== partsB[i]) {
+            ambiguous = false;
+        }
+    }
+    return ambiguous && aVars === bVars;
+}

package/lib/rules/common/no-enum-type-mismatch.d.ts

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

package/lib/rules/common/no-enum-type-mismatch.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoEnumTypeMismatch = void 0;
+const utils_1 = require("../utils");
+const NoEnumTypeMismatch = () => {
+    return {
+        Schema(schema, { report, location }) {
+            if (schema.enum && !Array.isArray(schema.enum))
+                return;
+            if (schema.enum && schema.type && !Array.isArray(schema.type)) {
+                const typeMismatchedValues = schema.enum.filter((item) => !(0, utils_1.matchesJsonSchemaType)(item, schema.type, schema.nullable));
+                for (const mismatchedValue of typeMismatchedValues) {
+                    report({
+                        message: `All values of \`enum\` field must be of the same type as the \`type\` field: expected "${schema.type}" but received "${(0, utils_1.oasTypeOf)(mismatchedValue)}".`,
+                        location: location.child(['enum', schema.enum.indexOf(mismatchedValue)]),
+                    });
+                }
+            }
+            if (schema.enum && schema.type && Array.isArray(schema.type)) {
+                const mismatchedResults = {};
+                for (const enumValue of schema.enum) {
+                    mismatchedResults[enumValue] = [];
+                    for (const type of schema.type) {
+                        const valid = (0, utils_1.matchesJsonSchemaType)(enumValue, type, schema.nullable);
+                        if (!valid)
+                            mismatchedResults[enumValue].push(type);
+                    }
+                    if (mismatchedResults[enumValue].length !== schema.type.length)
+                        delete mismatchedResults[enumValue];
+                }
+                for (const mismatchedKey of Object.keys(mismatchedResults)) {
+                    report({
+                        message: `Enum value \`${mismatchedKey}\` must be of allowed types: \`${schema.type}\`.`,
+                        location: location.child(['enum', schema.enum.indexOf(mismatchedKey)]),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.NoEnumTypeMismatch = NoEnumTypeMismatch;

package/lib/rules/common/no-http-verbs-in-paths.d.ts

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

package/lib/rules/common/no-http-verbs-in-paths.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoHttpVerbsInPaths = void 0;
+const utils_1 = require("../../utils");
+const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+const NoHttpVerbsInPaths = ({ splitIntoWords }) => {
+    return {
+        PathItem(_path, { key, report, location }) {
+            const pathKey = key.toString();
+            if (!pathKey.startsWith('/'))
+                return;
+            const pathSegments = pathKey.split('/');
+            for (const pathSegment of pathSegments) {
+                if (!pathSegment || (0, utils_1.isPathParameter)(pathSegment))
+                    continue;
+                const isHttpMethodIncluded = (method) => {
+                    return splitIntoWords
+                        ? (0, utils_1.splitCamelCaseIntoWords)(pathSegment).has(method)
+                        : pathSegment.toLocaleLowerCase().includes(method);
+                };
+                for (const method of httpMethods) {
+                    if (isHttpMethodIncluded(method)) {
+                        report({
+                            message: `path \`${pathKey}\` should not contain http verb ${method}`,
+                            location: location.key(),
+                        });
+                    }
+                }
+            }
+        },
+    };
+};
+exports.NoHttpVerbsInPaths = NoHttpVerbsInPaths;

package/lib/rules/common/no-identical-paths.d.ts

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

package/lib/rules/common/no-identical-paths.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoIdenticalPaths = void 0;
+const NoIdenticalPaths = () => {
+    return {
+        Paths(pathMap, { report, location }) {
+            const Paths = new Map();
+            for (const pathName of Object.keys(pathMap)) {
+                const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
+                const existingSamePath = Paths.get(id);
+                if (existingSamePath) {
+                    report({
+                        message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
+                        location: location.child([pathName]).key(),
+                    });
+                }
+                else {
+                    Paths.set(id, pathName);
+                }
+            }
+        },
+    };
+};
+exports.NoIdenticalPaths = NoIdenticalPaths;

package/lib/rules/common/no-invalid-parameter-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidParameterExamples: any;

package/lib/rules/common/no-invalid-parameter-examples.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidParameterExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidParameterExamples = (opts) => {
+    const allowAdditionalProperties = (0, utils_1.getAdditionalPropertiesOption)(opts) ?? false;
+    return {
+        Parameter: {
+            leave(parameter, ctx) {
+                if (parameter.example !== undefined) {
+                    (0, utils_1.validateExample)(parameter.example, parameter.schema, ctx.location.child('example'), ctx, allowAdditionalProperties);
+                }
+                if (parameter.examples) {
+                    for (const [key, example] of Object.entries(parameter.examples)) {
+                        if ('value' in example) {
+                            (0, utils_1.validateExample)(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, true);
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidParameterExamples = NoInvalidParameterExamples;

package/lib/rules/common/no-invalid-schema-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidSchemaExamples: any;

package/lib/rules/common/no-invalid-schema-examples.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidSchemaExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidSchemaExamples = (opts) => {
+    const allowAdditionalProperties = (0, utils_1.getAdditionalPropertiesOption)(opts) ?? false;
+    return {
+        Schema: {
+            leave(schema, ctx) {
+                if (schema.examples) {
+                    for (const example of schema.examples) {
+                        (0, utils_1.validateExample)(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, allowAdditionalProperties);
+                    }
+                }
+                if (schema.example !== undefined) {
+                    (0, utils_1.validateExample)(schema.example, schema, ctx.location.child('example'), ctx, true);
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidSchemaExamples = NoInvalidSchemaExamples;

package/lib/rules/common/no-path-trailing-slash.d.ts

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

package/lib/rules/common/no-path-trailing-slash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoPathTrailingSlash = void 0;
+const NoPathTrailingSlash = () => {
+    return {
+        PathItem(_path, { report, key, rawLocation }) {
+            if (key.endsWith('/') && key !== '/') {
+                report({
+                    message: `\`${key}\` should not have a trailing slash.`,
+                    location: rawLocation.key(),
+                });
+            }
+        },
+    };
+};
+exports.NoPathTrailingSlash = NoPathTrailingSlash;

package/lib/rules/common/no-required-schema-properties-undefined.d.ts

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

package/lib/rules/common/no-required-schema-properties-undefined.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoRequiredSchemaPropertiesUndefined = void 0;
+const ref_utils_1 = require("../../ref-utils");
+const NoRequiredSchemaPropertiesUndefined = () => {
+    return {
+        Schema: {
+            enter(schema, { location, report, resolve }) {
+                if (!schema.required)
+                    return;
+                const visitedSchemas = new Set();
+                const elevateProperties = (schema) => {
+                    // Check if the schema has been visited before processing it
+                    if (visitedSchemas.has(schema)) {
+                        return {};
+                    }
+                    visitedSchemas.add(schema);
+                    if ((0, ref_utils_1.isRef)(schema)) {
+                        return elevateProperties(resolve(schema).node);
+                    }
+                    return Object.assign({}, schema.properties, ...(schema.allOf?.map(elevateProperties) ?? []), ...(schema.anyOf?.map(elevateProperties) ?? []));
+                };
+                const allProperties = elevateProperties(schema);
+                for (const [i, requiredProperty] of schema.required.entries()) {
+                    if (!allProperties || allProperties[requiredProperty] === undefined) {
+                        report({
+                            message: `Required property '${requiredProperty}' is undefined.`,
+                            location: location.child(['required', i]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+exports.NoRequiredSchemaPropertiesUndefined = NoRequiredSchemaPropertiesUndefined;

package/lib/rules/common/operation-2xx-response.d.ts

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

package/lib/rules/common/operation-2xx-response.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation2xxResponse = void 0;
+const utils_1 = require("../utils");
+const Operation2xxResponse = ({ validateWebhooks }) => {
+    return {
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                (0, utils_1.validateResponseCodes)(codes, '2XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                (0, utils_1.validateResponseCodes)(codes, '2XX', { report });
+            },
+        },
+    };
+};
+exports.Operation2xxResponse = Operation2xxResponse;

package/lib/rules/common/operation-4xx-response.d.ts

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

package/lib/rules/common/operation-4xx-response.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation4xxResponse = void 0;
+const utils_1 = require("../utils");
+const Operation4xxResponse = ({ validateWebhooks }) => {
+    return {
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                (0, utils_1.validateResponseCodes)(codes, '4XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                (0, utils_1.validateResponseCodes)(codes, '4XX', { report });
+            },
+        },
+    };
+};
+exports.Operation4xxResponse = Operation4xxResponse;

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

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

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

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

package/lib/rules/common/operation-operationId-unique.d.ts

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

package/lib/rules/common/operation-operationId-unique.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationIdUnique = void 0;
+const OperationIdUnique = () => {
+    const seenOperations = new Set();
+    return {
+        Operation(operation, { report, location }) {
+            if (!operation.operationId)
+                return;
+            if (seenOperations.has(operation.operationId)) {
+                report({
+                    message: 'Every operation must have a unique `operationId`.',
+                    location: location.child([operation.operationId]),
+                });
+            }
+            seenOperations.add(operation.operationId);
+        },
+    };
+};
+exports.OperationIdUnique = OperationIdUnique;

package/lib/rules/common/operation-operationId-url-safe.d.ts

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

package/lib/rules/common/operation-operationId-url-safe.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationIdUrlSafe = void 0;
+// eslint-disable-next-line no-useless-escape
+const validUrlSymbols = /^[A-Za-z0-9-._~:/?#\[\]@!\$&'()*+,;=]*$/;
+const OperationIdUrlSafe = () => {
+    return {
+        Operation(operation, { report, location }) {
+            if (operation.operationId && !validUrlSymbols.test(operation.operationId)) {
+                report({
+                    message: 'Operation `operationId` should not have URL invalid characters.',
+                    location: location.child(['operationId']),
+                });
+            }
+        },
+    };
+};
+exports.OperationIdUrlSafe = OperationIdUrlSafe;

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

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

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

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

package/lib/rules/common/operation-parameters-unique.d.ts

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

package/lib/rules/common/operation-parameters-unique.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationParametersUnique = void 0;
+const OperationParametersUnique = () => {
+    let seenPathParams;
+    let seenOperationParams;
+    return {
+        PathItem: {
+            enter() {
+                seenPathParams = new Set();
+            },
+            Parameter(parameter, { report, key, parentLocations }) {
+                const paramId = `${parameter.in}___${parameter.name}`;
+                if (seenPathParams.has(paramId)) {
+                    report({
+                        message: `Paths must have unique \`name\` + \`in\` parameters.\nRepeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+                        location: parentLocations.PathItem.child(['parameters', key]),
+                    });
+                }
+                seenPathParams.add(`${parameter.in}___${parameter.name}`);
+            },
+            Operation: {
+                enter() {
+                    seenOperationParams = new Set();
+                },
+                Parameter(parameter, { report, key, parentLocations }) {
+                    const paramId = `${parameter.in}___${parameter.name}`;
+                    if (seenOperationParams.has(paramId)) {
+                        report({
+                            message: `Operations must have unique \`name\` + \`in\` parameters. Repeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+                            location: parentLocations.Operation.child(['parameters', key]),
+                        });
+                    }
+                    seenOperationParams.add(paramId);
+                },
+            },
+        },
+    };
+};
+exports.OperationParametersUnique = OperationParametersUnique;

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

@@ -0,0 +1,2 @@
+import type { 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 type { 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) {
+            (0, utils_1.validateDefinedAndNonEmpty)('summary', operation, ctx);
+        },
+    };
+};
+exports.OperationSummary = OperationSummary;

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationTagDefined = void 0;
+const OperationTagDefined = () => {
+    let definedTags;
+    return {
+        Root(root) {
+            definedTags = new Set((root.tags ?? []).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 type { 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 type { 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 type { 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 type { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const PathHttpVerbsOrder: Oas3Rule | Oas2Rule;