@swagger-api/apidom-ns-openapi-3-1 0.68.1

package/es/predicates.js

@@ -0,0 +1,237 @@
+import { createPredicate, isBooleanElement, isStringElement } from '@swagger-api/apidom-core';
+import CallbackElement from "./elements/Callback.js";
+import ComponentsElement from "./elements/Components.js";
+import ContactElement from "./elements/Contact.js";
+import ExampleElement from "./elements/Example.js";
+import ExternalDocumentationElement from "./elements/ExternalDocumentation.js";
+import HeaderElement from "./elements/Header.js";
+import InfoElement from "./elements/Info.js";
+import JsonSchemaDialectElement from "./elements/JsonSchemaDialect.js";
+import LicenseElement from "./elements/License.js";
+import LinkElement from "./elements/Link.js";
+import OpenapiElement from "./elements/Openapi.js";
+import OpenApi3_1Element from "./elements/OpenApi3-1.js";
+import OperationElement from "./elements/Operation.js";
+import ParameterElement from "./elements/Parameter.js";
+import PathItemElement from "./elements/PathItem.js";
+import PathsElement from "./elements/Paths.js";
+import ReferenceElement from "./elements/Reference.js";
+import RequestBodyElement from "./elements/RequestBody.js";
+import ResponseElement from "./elements/Response.js";
+import ResponsesElement from "./elements/Responses.js";
+import SchemaElement from "./elements/Schema.js";
+import SecurityRequirementElement from "./elements/SecurityRequirement.js";
+import ServerElement from "./elements/Server.js";
+import ServerVariableElement from "./elements/ServerVariable.js";
+import MediaTypeElement from "./elements/MediaType.js";
+export const isCallbackElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof CallbackElement || hasBasicElementProps(element) && isElementType('callback', element) && primitiveEq('object', element);
+});
+export const isComponentsElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ComponentsElement || hasBasicElementProps(element) && isElementType('components', element) && primitiveEq('object', element);
+});
+export const isContactElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ContactElement || hasBasicElementProps(element) && isElementType('contact', element) && primitiveEq('object', element);
+});
+export const isExampleElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ExampleElement || hasBasicElementProps(element) && isElementType('example', element) && primitiveEq('object', element);
+});
+export const isExternalDocumentationElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ExternalDocumentationElement || hasBasicElementProps(element) && isElementType('externalDocumentation', element) && primitiveEq('object', element);
+});
+export const isHeaderElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof HeaderElement || hasBasicElementProps(element) && isElementType('header', element) && primitiveEq('object', element);
+});
+export const isInfoElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof InfoElement || hasBasicElementProps(element) && isElementType('info', element) && primitiveEq('object', element);
+});
+export const isJsonSchemaDialectElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof JsonSchemaDialectElement || hasBasicElementProps(element) && isElementType('jsonSchemaDialect', element) && primitiveEq('string', element);
+});
+export const isLicenseElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof LicenseElement || hasBasicElementProps(element) && isElementType('license', element) && primitiveEq('object', element);
+});
+export const isLinkElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof LinkElement || hasBasicElementProps(element) && isElementType('link', element) && primitiveEq('object', element);
+});
+export const isLinkElementExternal = element => {
+  if (!isLinkElement(element)) {
+    return false;
+  }
+  if (!isStringElement(element.operationRef)) {
+    return false;
+  }
+  const value = element.operationRef.toValue();
+  return typeof value === 'string' && value.length > 0 && !value.startsWith('#');
+};
+export const isOpenapiElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof OpenapiElement || hasBasicElementProps(element) && isElementType('openapi', element) && primitiveEq('string', element);
+});
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const isOpenApi3_1Element = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq,
+  hasClass
+}) => {
+  return element => element instanceof OpenApi3_1Element || hasBasicElementProps(element) && isElementType('openApi3_1', element) && primitiveEq('object', element) && hasClass('api', element);
+});
+export const isOperationElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof OperationElement || hasBasicElementProps(element) && isElementType('operation', element) && primitiveEq('object', element);
+});
+export const isParameterElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ParameterElement || hasBasicElementProps(element) && isElementType('parameter', element) && primitiveEq('object', element);
+});
+export const isPathItemElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof PathItemElement || hasBasicElementProps(element) && isElementType('pathItem', element) && primitiveEq('object', element);
+});
+export const isPathItemElementExternal = element => {
+  if (!isPathItemElement(element)) {
+    return false;
+  }
+  if (!isStringElement(element.$ref)) {
+    return false;
+  }
+  const value = element.$ref.toValue();
+  return typeof value === 'string' && value.length > 0 && !value.startsWith('#');
+};
+export const isPathsElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof PathsElement || hasBasicElementProps(element) && isElementType('paths', element) && primitiveEq('object', element);
+});
+export const isReferenceElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ReferenceElement || hasBasicElementProps(element) && isElementType('reference', element) && primitiveEq('object', element);
+});
+export const isReferenceElementExternal = element => {
+  if (!isReferenceElement(element)) {
+    return false;
+  }
+  if (!isStringElement(element.$ref)) {
+    return false;
+  }
+  const value = element.$ref.toValue();
+  return typeof value === 'string' && value.length > 0 && !value.startsWith('#');
+};
+export const isRequestBodyElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof RequestBodyElement || hasBasicElementProps(element) && isElementType('requestBody', element) && primitiveEq('object', element);
+});
+export const isResponseElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ResponseElement || hasBasicElementProps(element) && isElementType('response', element) && primitiveEq('object', element);
+});
+export const isResponsesElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ResponsesElement || hasBasicElementProps(element) && isElementType('responses', element) && primitiveEq('object', element);
+});
+export const isSchemaElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof SchemaElement || hasBasicElementProps(element) && isElementType('schema', element) && primitiveEq('object', element);
+});
+export const isBooleanJsonSchemaElement = element => {
+  return isBooleanElement(element) && element.classes.includes('boolean-json-schema');
+};
+export const isSecurityRequirementElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof SecurityRequirementElement || hasBasicElementProps(element) && isElementType('securityRequirement', element) && primitiveEq('object', element);
+});
+export const isServerElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ServerElement || hasBasicElementProps(element) && isElementType('server', element) && primitiveEq('object', element);
+});
+export const isServerVariableElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ServerVariableElement || hasBasicElementProps(element) && isElementType('serverVariable', element) && primitiveEq('object', element);
+});
+export const isMediaTypeElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof MediaTypeElement || hasBasicElementProps(element) && isElementType('mediaType', element) && primitiveEq('object', element);
+});

package/es/refractor/index.js

@@ -0,0 +1,43 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { invokeArgs } from 'ramda-adjunct';
+import { visit, dereference, refract as baseRefract, dispatchRefractorPlugins } from '@swagger-api/apidom-core';
+import specification from "./specification.js";
+import { keyMap, getNodeType } from "../traversal/visitor.js";
+import createToolbox from "./toolbox.js";
+const refract = (value, {
+  specPath = ['visitors', 'document', 'objects', 'OpenApi', '$visitor'],
+  plugins = []
+} = {}) => {
+  const element = baseRefract(value);
+  const resolvedSpec = dereference(specification);
+
+  /**
+   * This is where generic ApiDOM becomes semantic (namespace applied).
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
+   */
+  const rootVisitor = invokeArgs(specPath, [], resolvedSpec);
+  // @ts-ignore
+  visit(element, rootVisitor, {
+    state: {
+      specObj: resolvedSpec
+    }
+  });
+
+  /**
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchRefractorPlugins(rootVisitor.element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      keyMap,
+      nodeTypeGetter: getNodeType
+    }
+  });
+};
+export const createRefractor = specPath => (value, options = {}) => refract(value, _objectSpread({
+  specPath
+}, options));
+export default refract;

package/es/refractor/plugins/normalize-header-examples.js

@@ -0,0 +1,73 @@
+/**
+ * Override of Schema.example and Schema.examples field inside the Header Objects.
+ *
+ * Header Object has two fixed fields:
+ *  - `example` of type `Any`
+ *  - `examples` of type `Map[string, Example Object | Reference Object]`
+ *
+ * OpenAPI 3.1 specification excerpt that defines the override behavior:
+ *
+ * The example value SHALL override the example provided by the schema.
+ * Furthermore, if referencing a schema that contains an example, the examples value SHALL override the example provided by the schema.
+ */
+/* eslint-disable no-param-reassign */
+const plugin = () => ({
+  predicates
+}) => {
+  return {
+    visitor: {
+      HeaderElement: {
+        leave(headerElement, key, parent, path, ancestors) {
+          var _headerElement$schema, _headerElement$schema2;
+          // skip visiting this Header Object
+          if (ancestors.some(predicates.isComponentsElement)) {
+            return;
+          }
+
+          // no Header.schema field present
+          if (typeof headerElement.schema === 'undefined' || !predicates.isSchemaElement(headerElement.schema)) {
+            return;
+          }
+          // Schema contains no example
+          if (typeof ((_headerElement$schema = headerElement.schema) === null || _headerElement$schema === void 0 ? void 0 : _headerElement$schema.example) === 'undefined' && typeof ((_headerElement$schema2 = headerElement.schema) === null || _headerElement$schema2 === void 0 ? void 0 : _headerElement$schema2.examples) === 'undefined') {
+            return;
+          }
+
+          /**
+           * Header.examples and Schema.examples have preferences over the older
+           * and deprected `example` field.
+           */
+          if (typeof headerElement.examples !== 'undefined' && predicates.isObjectElement(headerElement.examples)) {
+            // @ts-ignore
+            const examples = headerElement.examples.map(example => {
+              var _example$value;
+              return (_example$value = example.value) === null || _example$value === void 0 ? void 0 : _example$value.clone();
+            });
+            if (typeof headerElement.schema.examples !== 'undefined') {
+              headerElement.schema.set('examples', examples);
+            }
+            if (typeof headerElement.schema.example !== 'undefined') {
+              headerElement.schema.set('example', examples);
+            }
+            return;
+          }
+
+          /**
+           * Handle deprecated `example` field.
+           */
+          if (typeof headerElement.example !== 'undefined') {
+            if (typeof headerElement.schema.examples !== 'undefined') {
+              headerElement.schema.set('examples', [headerElement.example.clone()]);
+            }
+            if (typeof headerElement.schema.example !== 'undefined') {
+              headerElement.schema.set('example', headerElement.example.clone());
+            }
+          }
+        }
+      }
+    }
+  };
+};
+/* eslint-enable */
+
+export default plugin;

package/es/refractor/plugins/normalize-operation-ids.js

@@ -0,0 +1,136 @@
+import { last, defaultTo, groupBy } from 'ramda';
+import { toValue } from '@swagger-api/apidom-core';
+const removeSpaces = operationId => {
+  return operationId.replace(/\s/g, '');
+};
+const replaceSpecialCharsWithUnderscore = operationId => {
+  return operationId.replace(/\W/gi, '_');
+};
+const createNormalizedOperationId = (path, method) => {
+  const normalizedMethod = replaceSpecialCharsWithUnderscore(removeSpaces(method.toLowerCase()));
+  const normalizedPath = replaceSpecialCharsWithUnderscore(removeSpaces(path));
+  return `${normalizedMethod}${normalizedPath}`;
+};
+const normalizeOperationId = (operationId, path, method) => {
+  const withoutSpaces = removeSpaces(operationId);
+  if (withoutSpaces.length > 0) {
+    return replaceSpecialCharsWithUnderscore(withoutSpaces);
+  }
+  return createNormalizedOperationId(path, method);
+};
+
+/**
+ * Normalization of Operation.operationId field.
+ *
+ * This normalization is not guided by OpenAPI 3.1 specification.
+ *
+ * Existing Operation.operationId fields are normalized into snake case form.
+ *
+ * Operation Objects, that do not define operationId field, are left untouched.
+ *
+ * Original operationId is stored in meta and as new `__originalOperationId` field.
+ *
+ * This plugin also guarantees the uniqueness of all defined Operation.operationId fields,
+ * and make sure Link.operationId fields are pointing to correct and normalized Operation.operationId fields.
+ *
+ */
+/* eslint-disable no-param-reassign */
+
+const plugin = ({
+  operationIdNormalizer = normalizeOperationId
+} = {}) => ({
+  predicates,
+  namespace
+}) => {
+  const paths = [];
+  const normalizedOperations = [];
+  const links = [];
+  return {
+    visitor: {
+      OpenApi3_1Element: {
+        leave() {
+          // group normalized operations by normalized operationId
+          const normalizedOperationGroups = groupBy(operationElement => {
+            return toValue(operationElement.operationId);
+          }, normalizedOperations);
+
+          // append incremental numerical suffixes to identical operationIds
+          Object.entries(normalizedOperationGroups).forEach(([normalizedOperationId, operationElements]) => {
+            if (operationElements.length <= 1) return;
+            operationElements.forEach((operationElement, index) => {
+              const indexedNormalizedOperationId = `${normalizedOperationId}${index + 1}`;
+              // @ts-ignore
+              operationElement.operationId = new namespace.elements.String(indexedNormalizedOperationId);
+            });
+          });
+
+          // rectify possibly broken Link.operationId fields
+          links.forEach(linkElement => {
+            var _operationElement$ope;
+            if (typeof linkElement.operationId === 'undefined') return;
+            const linkOperationId = String(toValue(linkElement.operationId));
+            const operationElement = normalizedOperations.find(normalizedOperationElement => {
+              const originalOperationId = toValue(normalizedOperationElement.meta.get('originalOperationId'));
+              return originalOperationId === linkOperationId;
+            });
+
+            // Link Object doesn't need to be rectified
+            if (typeof operationElement === 'undefined') return;
+            linkElement.operationId = (_operationElement$ope = operationElement.operationId) === null || _operationElement$ope === void 0 ? void 0 : _operationElement$ope.clone();
+            linkElement.meta.set('originalOperationId', linkOperationId);
+            linkElement.set('__originalOperationId', linkOperationId);
+          });
+
+          // cleanup the references
+          normalizedOperations.length = 0;
+          links.length = 0;
+        }
+      },
+      PathItemElement: {
+        enter(pathItemElement) {
+          // `path` meta may not be always available, e.g. in Callback Object or Components Object
+          const path = defaultTo('path', toValue(pathItemElement.meta.get('path')));
+          paths.push(path);
+        },
+        leave() {
+          paths.pop();
+        }
+      },
+      OperationElement: {
+        enter(operationElement) {
+          // operationId field is undefined, needs no normalization
+          if (typeof operationElement.operationId === 'undefined') return;
+
+          // cast operationId to string type
+          const originalOperationId = String(toValue(operationElement.operationId));
+          // perform operationId normalization
+          const path = last(paths);
+          // `http-method` meta may not be always available, e.g. in Callback Object or Components Object
+          const method = defaultTo('method', toValue(operationElement.meta.get('http-method')));
+          const normalizedOperationId = operationIdNormalizer(originalOperationId, path, method);
+
+          // normalization is not necessary
+          if (originalOperationId === normalizedOperationId) return;
+
+          // @ts-ignore
+          operationElement.operationId = new namespace.elements.String(normalizedOperationId);
+          operationElement.set('__originalOperationId', originalOperationId);
+          operationElement.meta.set('originalOperationId', originalOperationId);
+          normalizedOperations.push(operationElement);
+        }
+      },
+      LinkElement: {
+        leave(linkElement) {
+          // make sure this Link elements doesn't come from base namespace
+          if (!predicates.isLinkElement(linkElement)) return;
+          // ignore Link Objects with undefined operationId
+          if (typeof linkElement.operationId === 'undefined') return;
+          links.push(linkElement);
+        }
+      }
+    }
+  };
+};
+/* eslint-enable */
+
+export default plugin;

package/es/refractor/plugins/normalize-parameter-examples.js

@@ -0,0 +1,73 @@
+/**
+ * Override of Schema.example and Schema.examples field inside the Parameter Objects.
+ *
+ * Parameter Object has two fixed fields:
+ *  - `example` of type `Any`
+ *  - `examples` of type `Map[string, Example Object | Reference Object]`
+ *
+ * OpenAPI 3.1 specification excerpt that defines the override behavior:
+ *
+ * The example value SHALL override the example provided by the schema.
+ * Furthermore, if referencing a schema that contains an example, the examples value SHALL override the example provided by the schema.
+ */
+/* eslint-disable no-param-reassign */
+const plugin = () => ({
+  predicates
+}) => {
+  return {
+    visitor: {
+      ParameterElement: {
+        leave(parameterElement, key, parent, path, ancestors) {
+          var _parameterElement$sch, _parameterElement$sch2;
+          // skip visiting this Parameter Object
+          if (ancestors.some(predicates.isComponentsElement)) {
+            return;
+          }
+
+          // no Parameter.schema field present
+          if (typeof parameterElement.schema === 'undefined' || !predicates.isSchemaElement(parameterElement.schema)) {
+            return;
+          }
+          // Schema contains no example
+          if (typeof ((_parameterElement$sch = parameterElement.schema) === null || _parameterElement$sch === void 0 ? void 0 : _parameterElement$sch.example) === 'undefined' && typeof ((_parameterElement$sch2 = parameterElement.schema) === null || _parameterElement$sch2 === void 0 ? void 0 : _parameterElement$sch2.examples) === 'undefined') {
+            return;
+          }
+
+          /**
+           * Parameter.examples and Schema.examples have preferences over the older
+           * and deprected `example` field.
+           */
+          if (typeof parameterElement.examples !== 'undefined' && predicates.isObjectElement(parameterElement.examples)) {
+            // @ts-ignore
+            const examples = parameterElement.examples.map(example => {
+              var _example$value;
+              return (_example$value = example.value) === null || _example$value === void 0 ? void 0 : _example$value.clone();
+            });
+            if (typeof parameterElement.schema.examples !== 'undefined') {
+              parameterElement.schema.set('examples', examples);
+            }
+            if (typeof parameterElement.schema.example !== 'undefined') {
+              parameterElement.schema.set('example', examples);
+            }
+            return;
+          }
+
+          /**
+           * Handle deprecated `example` field.
+           */
+          if (typeof parameterElement.example !== 'undefined') {
+            if (typeof parameterElement.schema.examples !== 'undefined') {
+              parameterElement.schema.set('examples', [parameterElement.example.clone()]);
+            }
+            if (typeof parameterElement.schema.example !== 'undefined') {
+              parameterElement.schema.set('example', parameterElement.example.clone());
+            }
+          }
+        }
+      }
+    }
+  };
+};
+/* eslint-enable */
+
+export default plugin;

package/es/refractor/plugins/normalize-parameters.js

@@ -0,0 +1,73 @@
+import { uniqWith, pathOr, last } from 'ramda';
+import { toValue } from '@swagger-api/apidom-core';
+import { OperationParametersElement } from '@swagger-api/apidom-ns-openapi-3-0';
+/**
+ * Inheritance of Parameter Objects.
+ *
+ * OpenAPI 3.1 specification excerpt that defines the inheritance behavior:
+ *
+ * A list of parameters that are applicable for this operation. If a parameter is already defined at the Path Item,
+ * the new definition will override it but can never remove it. The list MUST NOT include duplicated parameters.
+ * A unique parameter is defined by a combination of a name and location.
+ */
+/* eslint-disable no-param-reassign */
+const plugin = () => ({
+  predicates
+}) => {
+  /**
+   * Establishes identity between two Parameter Objects.
+   *
+   * {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#user-content-operationparameters}
+   */
+  const parameterEquals = (parameter1, parameter2) => {
+    if (!predicates.isParameterElement(parameter1)) return false;
+    if (!predicates.isParameterElement(parameter2)) return false;
+    if (!predicates.isStringElement(parameter1.name)) return false;
+    if (!predicates.isStringElement(parameter1.in)) return false;
+    if (!predicates.isStringElement(parameter2.name)) return false;
+    if (!predicates.isStringElement(parameter2.in)) return false;
+    return toValue(parameter1.name) === toValue(parameter2.name) && toValue(parameter1.in) === toValue(parameter2.in);
+  };
+  const pathItemParameters = [];
+  return {
+    visitor: {
+      PathItemElement: {
+        enter(pathItemElement, key, parent, path, ancestors) {
+          // skip visiting this Path Item
+          if (ancestors.some(predicates.isComponentsElement)) {
+            return;
+          }
+          const {
+            parameters
+          } = pathItemElement;
+          if (predicates.isArrayElement(parameters)) {
+            pathItemParameters.push([...parameters.content]);
+          } else {
+            pathItemParameters.push([]);
+          }
+        },
+        leave() {
+          pathItemParameters.pop();
+        }
+      },
+      OperationElement: {
+        leave(operationElement) {
+          const parentPathItemParameters = last(pathItemParameters);
+
+          // no Path Item Object parameters to inherit from
+          if (!Array.isArray(parentPathItemParameters) || parentPathItemParameters.length === 0) {
+            return;
+          }
+          const operationParameters = pathOr([], ['parameters', 'content'], operationElement);
+
+          // prefers the first item if two items compare equal based on the predicate
+          const mergedParameters = uniqWith(parameterEquals, [...operationParameters, ...parentPathItemParameters]);
+          operationElement.parameters = new OperationParametersElement(mergedParameters);
+        }
+      }
+    }
+  };
+};
+/* eslint-enable */
+
+export default plugin;