@redocly/openapi-core 1.0.0-beta.100

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

@@ -0,0 +1,20 @@
+import { ProblemSeverity, UserContext } from '../../../walk';
+export declare type OrderDirection = 'asc' | 'desc';
+export declare type OrderOptions = {
+    direction: OrderDirection;
+    property: string;
+};
+export declare type AssertToApply = {
+    name: string;
+    assertId?: string;
+    conditions: any;
+    message?: string;
+    severity?: ProblemSeverity;
+    suggest?: string[];
+    runsOnKeys: boolean;
+    runsOnValues: boolean;
+};
+export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
+export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type, resolve }: UserContext) => void;
+export declare function getIntersectionLength(keys: string[], properties: string[]): number;
+export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+const ref_utils_1 = require("../../../ref-utils");
+const asserts_1 = require("./asserts");
+function buildVisitorObject(subject, context, subjectVisitor) {
+    if (!context) {
+        return { [subject]: subjectVisitor };
+    }
+    let currentVisitorLevel = {};
+    const visitor = currentVisitorLevel;
+    for (let index = 0; index < context.length; index++) {
+        const node = context[index];
+        if (context.length === index + 1 && node.type === subject) {
+            // Visitors don't work properly for the same type nested nodes, so
+            // as a workaround for that we don't create separate visitor for the last element
+            // which is the same as subject;
+            // we will check includes/excludes it in the last visitor.
+            continue;
+        }
+        const matchParentKeys = node.matchParentKeys;
+        const excludeParentKeys = node.excludeParentKeys;
+        if (matchParentKeys && excludeParentKeys) {
+            throw new Error(`Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`);
+        }
+        if (matchParentKeys || excludeParentKeys) {
+            currentVisitorLevel[node.type] = {
+                skip: (_value, key) => {
+                    if (matchParentKeys) {
+                        return !matchParentKeys.includes(key);
+                    }
+                    if (excludeParentKeys) {
+                        return excludeParentKeys.includes(key);
+                    }
+                },
+            };
+        }
+        else {
+            currentVisitorLevel[node.type] = {};
+        }
+        currentVisitorLevel = currentVisitorLevel[node.type];
+    }
+    currentVisitorLevel[subject] = subjectVisitor;
+    return visitor;
+}
+exports.buildVisitorObject = buildVisitorObject;
+function buildSubjectVisitor(properties, asserts, context) {
+    return function (node, { report, location, key, type, resolve }) {
+        var _a;
+        // We need to check context's last node if it has the same type as subject node;
+        // if yes - that means we didn't create context's last node visitor,
+        // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
+        if (context) {
+            const lastContextNode = context[context.length - 1];
+            if (lastContextNode.type === type.name) {
+                const matchParentKeys = lastContextNode.matchParentKeys;
+                const excludeParentKeys = lastContextNode.excludeParentKeys;
+                if (matchParentKeys && !matchParentKeys.includes(key)) {
+                    return;
+                }
+                if (excludeParentKeys && excludeParentKeys.includes(key)) {
+                    return;
+                }
+            }
+        }
+        if (properties) {
+            properties = Array.isArray(properties) ? properties : [properties];
+        }
+        for (const assert of asserts) {
+            if (properties) {
+                for (const property of properties) {
+                    // we can have resolvable scalar so need to resolve value here.
+                    const value = ref_utils_1.isRef(node[property]) ? (_a = resolve(node[property])) === null || _a === void 0 ? void 0 : _a.node : node[property];
+                    runAssertion(value, assert, location.child(property), report);
+                }
+            }
+            else {
+                runAssertion(Object.keys(node), assert, location.key(), report);
+            }
+        }
+    };
+}
+exports.buildSubjectVisitor = buildSubjectVisitor;
+function getIntersectionLength(keys, properties) {
+    const props = new Set(properties);
+    let count = 0;
+    for (const key of keys) {
+        if (props.has(key)) {
+            count++;
+        }
+    }
+    return count;
+}
+exports.getIntersectionLength = getIntersectionLength;
+function isOrdered(value, options) {
+    const direction = options.direction || options;
+    const property = options.property;
+    for (let i = 1; i < value.length; i++) {
+        let currValue = value[i];
+        let prevVal = value[i - 1];
+        if (property) {
+            if (!value[i][property] || !value[i - 1][property]) {
+                return false; // property doesn't exist, so collection is not ordered
+            }
+            currValue = value[i][property];
+            prevVal = value[i - 1][property];
+        }
+        const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isOrdered = isOrdered;
+function runAssertion(values, assert, location, report) {
+    const lintResult = asserts_1.asserts[assert.name](values, assert.conditions);
+    if (!lintResult) {
+        report({
+            message: assert.message || `The ${assert.assertId} doesn't meet required conditions`,
+            location,
+            forceSeverity: assert.severity,
+            suggest: assert.suggest,
+            ruleId: assert.assertId,
+        });
+    }
+}

package/lib/rules/common/info-contact.d.ts

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

package/lib/rules/common/info-contact.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoContact = void 0;
+const utils_1 = require("../utils");
+const InfoContact = () => {
+    return {
+        Info(info, { report, location }) {
+            if (!info.contact) {
+                report({
+                    message: utils_1.missingRequiredField('Info', 'contact'),
+                    location: location.child('contact').key(),
+                });
+            }
+        },
+    };
+};
+exports.InfoContact = InfoContact;

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

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

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

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

package/lib/rules/common/info-license-url.d.ts

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

package/lib/rules/common/info-license-url.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoLicense = void 0;
+const utils_1 = require("../utils");
+const InfoLicense = () => {
+    return {
+        Info(info, { report }) {
+            if (!info.license) {
+                report({
+                    message: utils_1.missingRequiredField('Info', 'license'),
+                    location: { reportOnKey: true }
+                });
+            }
+        },
+    };
+};
+exports.InfoLicense = InfoLicense;

package/lib/rules/common/license-url.d.ts

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

package/lib/rules/common/license-url.js

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

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

@@ -0,0 +1,2 @@
+import { 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 {
+        PathMap(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 { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const NoEnumTypeMismatch: Oas3Rule | Oas2Rule;

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

@@ -0,0 +1,43 @@
+"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) => !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 "${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 = 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 one type. 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 { 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 || utils_1.isPathParameter(pathSegment))
+                    continue;
+                const isHttpMethodIncluded = (method) => {
+                    return splitIntoWords
+                        ? 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 { 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 {
+        PathMap(pathMap, { report, location }) {
+            const pathsMap = new Map();
+            for (const pathName of Object.keys(pathMap)) {
+                const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
+                const existingSamePath = pathsMap.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 {
+                    pathsMap.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,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidParameterExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidParameterExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Parameter: {
+            leave(parameter, ctx) {
+                if (parameter.example) {
+                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, disallowAdditionalProperties);
+                }
+                if (parameter.examples) {
+                    for (const [key, example] of Object.entries(parameter.examples)) {
+                        if ('value' in example) {
+                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, false);
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+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,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidSchemaExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidSchemaExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Schema: {
+            leave(schema, ctx) {
+                if (schema.examples) {
+                    for (const example of schema.examples) {
+                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, disallowAdditionalProperties);
+                    }
+                }
+                if (schema.example) {
+                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidSchemaExamples = NoInvalidSchemaExamples;

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

@@ -0,0 +1,2 @@
+import { 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, location }) {
+            if (key.endsWith('/') && key !== '/') {
+                report({
+                    message: `\`${key}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+exports.NoPathTrailingSlash = NoPathTrailingSlash;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation2xxResponse = void 0;
+const Operation2xxResponse = () => {
+    return {
+        ResponsesMap(responses, { report }) {
+            const codes = Object.keys(responses);
+            if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
+                report({
+                    message: 'Operation must have at least one `2xx` response.',
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.Operation2xxResponse = Operation2xxResponse;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation4xxResponse = void 0;
+const Operation4xxResponse = () => {
+    return {
+        ResponsesMap(responses, { report }) {
+            const codes = Object.keys(responses);
+            if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
+                report({
+                    message: 'Operation must have at least one `4xx` response.',
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.Operation4xxResponse = Operation4xxResponse;

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

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

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

@@ -0,0 +1,2 @@
+import { 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 { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const OperationIdUrlSafe: Oas3Rule | Oas2Rule;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationIdUrlSafe = void 0;
+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 { 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 {
+        DefinitionRoot: {
+            PathItem: {
+                Operation(operation, ctx) {
+                    utils_1.validateDefinedAndNonEmpty('operationId', operation, ctx);
+                },
+            },
+        }
+    };
+};
+exports.OperationOperationId = OperationOperationId;

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

@@ -0,0 +1,2 @@
+import { 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;