@speclynx/apidom-ns-openapi-2 1.12.1

package/src/refractor/plugins/replace-empty-element.mjs

@@ -0,0 +1,350 @@
+import { ArrayElement, ObjectElement, isStringElement, isElement, isMemberElement, isArrayElement, includesClasses, cloneDeep, toValue } from '@speclynx/apidom-core';
+
+/**
+ * OpenAPI 2.0 specification elements.
+ */
+import InfoElement from "../../elements/Info.mjs";
+import ContactElement from "../../elements/Contact.mjs";
+import LicenseElement from "../../elements/License.mjs";
+import PathsElement from "../../elements/Paths.mjs";
+import PathItemElement from "../../elements/PathItem.mjs";
+import OperationElement from "../../elements/Operation.mjs";
+import ExternalDocumentationElement from "../../elements/ExternalDocumentation.mjs";
+import ParameterElement from "../../elements/Parameter.mjs";
+import ItemsElement from "../../elements/Items.mjs";
+import ResponsesElement from "../../elements/Responses.mjs";
+import ResponseElement from "../../elements/Response.mjs";
+import HeadersElement from "../../elements/Headers.mjs";
+import ExampleElement from "../../elements/Example.mjs";
+import HeaderElement from "../../elements/Header.mjs";
+import TagElement from "../../elements/Tag.mjs";
+import SchemaElement from "../../elements/Schema.mjs";
+import XmlElement from "../../elements/Xml.mjs";
+import DefinitionsElement from "../../elements/Definitions.mjs";
+import ParametersDefinitionsElement from "../../elements/ParametersDefinitions.mjs";
+import ResponsesDefinitionsElement from "../../elements/ResponsesDefinitions.mjs";
+import SecurityDefinitionsElement from "../../elements/SecurityDefinitions.mjs";
+import SecuritySchemeElement from "../../elements/SecurityScheme.mjs";
+import ScopesElement from "../../elements/Scopes.mjs";
+import SecurityRequirementElement from "../../elements/SecurityRequirement.mjs"; // non-concrete Elements (NCEs)
+import OperationConsumesElement from "../../elements/nces/OperationConsumes.mjs";
+import OperationParametersElement from "../../elements/nces/OperationParameters.mjs";
+import OperationProducesElement from "../../elements/nces/OperationProduces.mjs";
+import OperationSchemesElement from "../../elements/nces/OperationSchemes.mjs";
+import OperationSecurityElement from "../../elements/nces/OperationSecurity.mjs";
+import OperationTagsElement from "../../elements/nces/OperationTags.mjs";
+import PathItemParametersElement from "../../elements/nces/PathItemParameters.mjs";
+import SwaggerSchemesElement from "../../elements/nces/SwaggerSchemes.mjs";
+import SwaggerConsumesElement from "../../elements/nces/SwaggerConsumes.mjs";
+import SwaggerProducesElement from "../../elements/nces/SwaggerProduces.mjs";
+import SwaggerSecurityElement from "../../elements/nces/SwaggerSecurity.mjs";
+import SwaggerTagsElement from "../../elements/nces/SwaggerTags.mjs";
+import { getNodeType } from "../../traversal/visitor.mjs";
+/**
+ * This plugin is specific to YAML 1.2 format, which allows defining key-value pairs
+ * with empty key, empty value, or both. If the value is not provided in YAML format,
+ * this plugin compensates for this missing value with the most appropriate semantic element type.
+ *
+ * https://yaml.org/spec/1.2.2/#72-empty-nodes
+ *
+ * @example
+ *
+ * ```yaml
+ * swagger: "2.0"
+ * info:
+ * ```
+ * Refracting result without this plugin:
+ *
+ *  (SwaggerElement
+ *    (MemberElement
+ *      (StringElement)
+ *      (SwaggerVersionElement))
+ *    (MemberElement
+ *      (StringElement)
+ *      (StringElement))
+ *
+ * Refracting result with this plugin:
+ *
+ *  (SwaggerElement
+ *    (MemberElement
+ *      (StringElement)
+ *      (SwaggerVersionElement))
+ *    (MemberElement
+ *      (StringElement)
+ *      (InfoElement))
+ */
+const isEmptyElement = element => isStringElement(element) && includesClasses(['yaml-e-node', 'yaml-e-scalar'], element);
+const schema = {
+  // concrete types handling (CTs)
+  SwaggerElement: {
+    info(...args) {
+      return new InfoElement(...args);
+    },
+    schemes(...args) {
+      return new SwaggerSchemesElement(...args);
+    },
+    consumes(...args) {
+      return new SwaggerConsumesElement(...args);
+    },
+    produces(...args) {
+      return new SwaggerProducesElement(...args);
+    },
+    paths(...args) {
+      return new PathsElement(...args);
+    },
+    definitions(...args) {
+      return new DefinitionsElement(...args);
+    },
+    parameters(...args) {
+      return new ParametersDefinitionsElement(...args);
+    },
+    responses(...args) {
+      return new ResponsesDefinitionsElement(...args);
+    },
+    securityDefinitions(...args) {
+      return new SecurityDefinitionsElement(...args);
+    },
+    security(...args) {
+      return new SwaggerSecurityElement(...args);
+    },
+    tags(...args) {
+      return new SwaggerTagsElement(...args);
+    },
+    externalDocs(...args) {
+      return new ExternalDocumentationElement(...args);
+    }
+  },
+  InfoElement: {
+    contact(...args) {
+      return new ContactElement(...args);
+    },
+    license(...args) {
+      return new LicenseElement(...args);
+    }
+  },
+  PathsElement: {
+    '[key: *]': function key(...args) {
+      return new PathItemElement(...args);
+    }
+  },
+  PathItemElement: {
+    get(...args) {
+      return new OperationElement(...args);
+    },
+    put(...args) {
+      return new OperationElement(...args);
+    },
+    post(...args) {
+      return new OperationElement(...args);
+    },
+    delete(...args) {
+      return new OperationElement(...args);
+    },
+    options(...args) {
+      return new OperationElement(...args);
+    },
+    head(...args) {
+      return new OperationElement(...args);
+    },
+    patch(...args) {
+      return new OperationElement(...args);
+    },
+    parameters(...args) {
+      return new PathItemParametersElement(...args);
+    }
+  },
+  OperationElement: {
+    tags(...args) {
+      return new OperationTagsElement(...args);
+    },
+    externalDocs(...args) {
+      return new ExternalDocumentationElement(...args);
+    },
+    consumes(...args) {
+      return new OperationConsumesElement(...args);
+    },
+    produces(...args) {
+      return new OperationProducesElement(...args);
+    },
+    parameters(...args) {
+      return new OperationParametersElement(...args);
+    },
+    responses(...args) {
+      return new ResponsesElement(...args);
+    },
+    schemes(...args) {
+      return new OperationSchemesElement(...args);
+    },
+    security(...args) {
+      return new OperationSecurityElement(...args);
+    }
+  },
+  ParameterElement: {
+    schema(...args) {
+      return new SchemaElement(...args);
+    },
+    items(...args) {
+      return new ItemsElement(...args);
+    }
+  },
+  ItemsElement: {
+    items(...args) {
+      return new ItemsElement(...args);
+    }
+  },
+  ResponsesElement: {
+    '[key: *]': function key(...args) {
+      return new ResponseElement(...args);
+    }
+  },
+  ResponseElement: {
+    schema(...args) {
+      return new SchemaElement(...args);
+    },
+    headers(...args) {
+      return new HeadersElement(...args);
+    },
+    examples(...args) {
+      return new ExampleElement(...args);
+    }
+  },
+  HeadersElement: {
+    '[key: *]': function key(...args) {
+      return new HeaderElement(...args);
+    }
+  },
+  HeaderElement: {
+    items(...args) {
+      return new ItemsElement(...args);
+    }
+  },
+  TagElement: {
+    externalDocs(...args) {
+      return new ExternalDocumentationElement(...args);
+    }
+  },
+  SchemaElement: {
+    items(...args) {
+      return new SchemaElement(...args);
+    },
+    allOf(...args) {
+      const element = new ArrayElement(...args);
+      element.classes.push('json-schema-allOf');
+      return element;
+    },
+    properties(...args) {
+      const element = new ObjectElement(...args);
+      element.classes.push('json-schema-properties');
+      return element;
+    },
+    additionalProperties(...args) {
+      return new SchemaElement(...args);
+    },
+    xml(...args) {
+      return new XmlElement(...args);
+    },
+    externalDocs(...args) {
+      return new ExternalDocumentationElement(...args);
+    }
+  },
+  DefinitionsElement: {
+    '[key: *]': function key(...args) {
+      return new SchemaElement(...args);
+    }
+  },
+  ParametersDefinitionsElement: {
+    '[key: *]': function key(...args) {
+      return new ParameterElement(...args);
+    }
+  },
+  ResponsesDefinitionsElement: {
+    '[key: *]': function key(...args) {
+      return new ResponseElement(...args);
+    }
+  },
+  SecurityDefinitionsElement: {
+    '[key: *]': function key(...args) {
+      return new SecuritySchemeElement(...args);
+    }
+  },
+  SecuritySchemeElement: {
+    scopes(...args) {
+      return new ScopesElement(...args);
+    }
+  },
+  SecurityRequirementElement: {
+    '[key: *]': function key(...args) {
+      return new ArrayElement(...args);
+    }
+  },
+  // non-concrete types handling (NCEs)
+  [OperationParametersElement.primaryClass]: {
+    '<*>': function asterisk(...args) {
+      return new ParameterElement(...args);
+    }
+  },
+  [OperationSecurityElement.primaryClass]: {
+    '<*>': function asterisk(...args) {
+      return new SecurityRequirementElement(...args);
+    }
+  },
+  [PathItemParametersElement.primaryClass]: {
+    '<*>': function asterisk(...args) {
+      return new ParameterElement(...args);
+    }
+  },
+  [SwaggerSecurityElement.primaryClass]: {
+    '<*>': function asterisk(...args) {
+      return new SecurityRequirementElement(...args);
+    }
+  },
+  [SwaggerTagsElement.primaryClass]: {
+    '<*>': function asterisk(...args) {
+      return new TagElement(...args);
+    }
+  },
+  'json-schema-properties': {
+    '[key: *]': function key(...args) {
+      return new SchemaElement(...args);
+    }
+  },
+  'json-schema-allOf': {
+    '<*>': function asterisk(...args) {
+      return new SchemaElement(...args);
+    }
+  }
+};
+const findElementFactory = (ancestor, keyName) => {
+  const elementType = getNodeType(ancestor); // @ts-ignore
+  const keyMapping = schema[elementType] || schema[toValue(ancestor.classes.first)];
+  return typeof keyMapping === 'undefined' ? undefined : Object.hasOwn(keyMapping, '[key: *]') ? keyMapping['[key: *]'] : keyMapping[keyName];
+};
+
+/**
+ * @public
+ */
+const plugin = () => () => ({
+  visitor: {
+    StringElement(element, key, parent, path, ancestors) {
+      if (!isEmptyElement(element)) return undefined;
+      const lineage = [...ancestors, parent].filter(isElement);
+      const parentElement = lineage.at(-1);
+      let elementFactory;
+      let context;
+      if (isArrayElement(parentElement)) {
+        context = element;
+        elementFactory = findElementFactory(parentElement, '<*>');
+      } else if (isMemberElement(parentElement)) {
+        context = lineage.at(-2);
+        elementFactory = findElementFactory(context, toValue(parentElement.key));
+      }
+
+      // no element factory found
+      if (typeof elementFactory !== 'function') return undefined;
+      return elementFactory.call({
+        context
+      }, undefined, cloneDeep(element.meta), cloneDeep(element.attributes));
+    }
+  }
+});
+export default plugin;

package/src/refractor/predicates.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isSwaggerExtension = exports.isReferenceLikeElement = void 0;
+var _ramda = require("ramda");
+var _apidomCore = require("@speclynx/apidom-core");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+const isSwaggerExtension = element => {
+  return (0, _apidomCore.isStringElement)(element.key) && (0, _ramda.startsWith)('x-', (0, _apidomCore.toValue)(element.key));
+};
+
+/**
+ * @public
+ */
+exports.isSwaggerExtension = isSwaggerExtension;
+const isReferenceLikeElement = element => {
+  return (0, _apidomCore.isObjectElement)(element) && element.hasKey('$ref');
+};
+exports.isReferenceLikeElement = isReferenceLikeElement;

package/src/refractor/predicates.mjs

@@ -0,0 +1,20 @@
+import { startsWith } from 'ramda';
+import { isStringElement, toValue, isObjectElement } from '@speclynx/apidom-core';
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+export const isSwaggerExtension = element => {
+  return isStringElement(element.key) && startsWith('x-', toValue(element.key));
+};
+
+/**
+ * @public
+ */
+export const isReferenceLikeElement = element => {
+  return isObjectElement(element) && element.hasKey('$ref');
+};

package/src/refractor/registration.cjs

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+var _Swagger = _interopRequireDefault(require("../elements/Swagger.cjs"));
+exports.SwaggerElement = _Swagger.default;
+var _SwaggerVersion = _interopRequireDefault(require("../elements/SwaggerVersion.cjs"));
+exports.SwaggerVersionElement = _SwaggerVersion.default;
+var _Info = _interopRequireDefault(require("../elements/Info.cjs"));
+exports.InfoElement = _Info.default;
+var _Contact = _interopRequireDefault(require("../elements/Contact.cjs"));
+exports.ContactElement = _Contact.default;
+var _License = _interopRequireDefault(require("../elements/License.cjs"));
+exports.LicenseElement = _License.default;
+var _Paths = _interopRequireDefault(require("../elements/Paths.cjs"));
+exports.PathsElement = _Paths.default;
+var _PathItem = _interopRequireDefault(require("../elements/PathItem.cjs"));
+exports.PathItemElement = _PathItem.default;
+var _Operation = _interopRequireDefault(require("../elements/Operation.cjs"));
+exports.OperationElement = _Operation.default;
+var _ExternalDocumentation = _interopRequireDefault(require("../elements/ExternalDocumentation.cjs"));
+exports.ExternalDocumentationElement = _ExternalDocumentation.default;
+var _Parameter = _interopRequireDefault(require("../elements/Parameter.cjs"));
+exports.ParameterElement = _Parameter.default;
+var _Items = _interopRequireDefault(require("../elements/Items.cjs"));
+exports.ItemsElement = _Items.default;
+var _Responses = _interopRequireDefault(require("../elements/Responses.cjs"));
+exports.ResponsesElement = _Responses.default;
+var _Response = _interopRequireDefault(require("../elements/Response.cjs"));
+exports.ResponseElement = _Response.default;
+var _Headers = _interopRequireDefault(require("../elements/Headers.cjs"));
+exports.HeadersElement = _Headers.default;
+var _Example = _interopRequireDefault(require("../elements/Example.cjs"));
+exports.ExampleElement = _Example.default;
+var _Header = _interopRequireDefault(require("../elements/Header.cjs"));
+exports.HeaderElement = _Header.default;
+var _Tag = _interopRequireDefault(require("../elements/Tag.cjs"));
+exports.TagElement = _Tag.default;
+var _Reference = _interopRequireDefault(require("../elements/Reference.cjs"));
+exports.ReferenceElement = _Reference.default;
+var _Schema = _interopRequireDefault(require("../elements/Schema.cjs"));
+exports.SchemaElement = _Schema.default;
+var _Xml = _interopRequireDefault(require("../elements/Xml.cjs"));
+exports.XmlElement = _Xml.default;
+var _Definitions = _interopRequireDefault(require("../elements/Definitions.cjs"));
+exports.DefinitionsElement = _Definitions.default;
+var _ParametersDefinitions = _interopRequireDefault(require("../elements/ParametersDefinitions.cjs"));
+exports.ParametersDefinitionsElement = _ParametersDefinitions.default;
+var _ResponsesDefinitions = _interopRequireDefault(require("../elements/ResponsesDefinitions.cjs"));
+exports.ResponsesDefinitionsElement = _ResponsesDefinitions.default;
+var _SecurityDefinitions = _interopRequireDefault(require("../elements/SecurityDefinitions.cjs"));
+exports.SecurityDefinitionsElement = _SecurityDefinitions.default;
+var _SecurityScheme = _interopRequireDefault(require("../elements/SecurityScheme.cjs"));
+exports.SecuritySchemeElement = _SecurityScheme.default;
+var _Scopes = _interopRequireDefault(require("../elements/Scopes.cjs"));
+exports.ScopesElement = _Scopes.default;
+var _SecurityRequirement = _interopRequireDefault(require("../elements/SecurityRequirement.cjs"));
+exports.SecurityRequirementElement = _SecurityRequirement.default;
+var _index = require("./index.cjs");
+// register refractors specific to element types
+_Swagger.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Swagger', '$visitor']);
+_SwaggerVersion.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'SwaggerVersion', '$visitor']);
+_Info.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Info', '$visitor']);
+_Contact.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Contact', '$visitor']);
+_License.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'License', '$visitor']);
+_Paths.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Paths', '$visitor']);
+_PathItem.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'PathItem', '$visitor']);
+_Operation.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Operation', '$visitor']);
+_ExternalDocumentation.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'ExternalDocumentation', '$visitor']);
+_Parameter.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Parameter', '$visitor']);
+_Items.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Items', '$visitor']);
+_Responses.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Responses', '$visitor']);
+_Response.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Response', '$visitor']);
+_Headers.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Headers', '$visitor']);
+_Example.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Example', '$visitor']);
+_Header.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Header', '$visitor']);
+_Tag.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Tag', '$visitor']);
+_Reference.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Reference', '$visitor']);
+_Schema.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Schema', '$visitor']);
+_Xml.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'XML', '$visitor']);
+_Definitions.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Definitions', '$visitor']);
+_ParametersDefinitions.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'ParametersDefinitions', '$visitor']);
+_ResponsesDefinitions.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'ResponsesDefinitions', '$visitor']);
+_SecurityDefinitions.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'SecurityDefinitions', '$visitor']);
+_SecurityScheme.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'SecurityScheme', '$visitor']);
+_Scopes.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'Scopes', '$visitor']);
+_SecurityRequirement.default.refract = (0, _index.createRefractor)(['visitors', 'document', 'objects', 'SecurityRequirement', '$visitor']);

package/src/refractor/registration.mjs

@@ -0,0 +1,56 @@
+import SwaggerElement from "../elements/Swagger.mjs";
+import SwaggerVersionElement from "../elements/SwaggerVersion.mjs";
+import InfoElement from "../elements/Info.mjs";
+import ContactElement from "../elements/Contact.mjs";
+import LicenseElement from "../elements/License.mjs";
+import PathsElement from "../elements/Paths.mjs";
+import PathItemElement from "../elements/PathItem.mjs";
+import OperationElement from "../elements/Operation.mjs";
+import ExternalDocumentationElement from "../elements/ExternalDocumentation.mjs";
+import ParameterElement from "../elements/Parameter.mjs";
+import ItemsElement from "../elements/Items.mjs";
+import ResponsesElement from "../elements/Responses.mjs";
+import ResponseElement from "../elements/Response.mjs";
+import HeadersElement from "../elements/Headers.mjs";
+import ExampleElement from "../elements/Example.mjs";
+import HeaderElement from "../elements/Header.mjs";
+import TagElement from "../elements/Tag.mjs";
+import ReferenceElement from "../elements/Reference.mjs";
+import SchemaElement from "../elements/Schema.mjs";
+import XmlElement from "../elements/Xml.mjs";
+import DefinitionsElement from "../elements/Definitions.mjs";
+import ParametersDefinitionsElement from "../elements/ParametersDefinitions.mjs";
+import ResponsesDefinitionsElement from "../elements/ResponsesDefinitions.mjs";
+import SecurityDefinitionsElement from "../elements/SecurityDefinitions.mjs";
+import SecuritySchemeElement from "../elements/SecurityScheme.mjs";
+import ScopesElement from "../elements/Scopes.mjs";
+import SecurityRequirementElement from "../elements/SecurityRequirement.mjs";
+import { createRefractor } from "./index.mjs"; // register refractors specific to element types
+SwaggerElement.refract = createRefractor(['visitors', 'document', 'objects', 'Swagger', '$visitor']);
+SwaggerVersionElement.refract = createRefractor(['visitors', 'document', 'objects', 'SwaggerVersion', '$visitor']);
+InfoElement.refract = createRefractor(['visitors', 'document', 'objects', 'Info', '$visitor']);
+ContactElement.refract = createRefractor(['visitors', 'document', 'objects', 'Contact', '$visitor']);
+LicenseElement.refract = createRefractor(['visitors', 'document', 'objects', 'License', '$visitor']);
+PathsElement.refract = createRefractor(['visitors', 'document', 'objects', 'Paths', '$visitor']);
+PathItemElement.refract = createRefractor(['visitors', 'document', 'objects', 'PathItem', '$visitor']);
+OperationElement.refract = createRefractor(['visitors', 'document', 'objects', 'Operation', '$visitor']);
+ExternalDocumentationElement.refract = createRefractor(['visitors', 'document', 'objects', 'ExternalDocumentation', '$visitor']);
+ParameterElement.refract = createRefractor(['visitors', 'document', 'objects', 'Parameter', '$visitor']);
+ItemsElement.refract = createRefractor(['visitors', 'document', 'objects', 'Items', '$visitor']);
+ResponsesElement.refract = createRefractor(['visitors', 'document', 'objects', 'Responses', '$visitor']);
+ResponseElement.refract = createRefractor(['visitors', 'document', 'objects', 'Response', '$visitor']);
+HeadersElement.refract = createRefractor(['visitors', 'document', 'objects', 'Headers', '$visitor']);
+ExampleElement.refract = createRefractor(['visitors', 'document', 'objects', 'Example', '$visitor']);
+HeaderElement.refract = createRefractor(['visitors', 'document', 'objects', 'Header', '$visitor']);
+TagElement.refract = createRefractor(['visitors', 'document', 'objects', 'Tag', '$visitor']);
+ReferenceElement.refract = createRefractor(['visitors', 'document', 'objects', 'Reference', '$visitor']);
+SchemaElement.refract = createRefractor(['visitors', 'document', 'objects', 'Schema', '$visitor']);
+XmlElement.refract = createRefractor(['visitors', 'document', 'objects', 'XML', '$visitor']);
+DefinitionsElement.refract = createRefractor(['visitors', 'document', 'objects', 'Definitions', '$visitor']);
+ParametersDefinitionsElement.refract = createRefractor(['visitors', 'document', 'objects', 'ParametersDefinitions', '$visitor']);
+ResponsesDefinitionsElement.refract = createRefractor(['visitors', 'document', 'objects', 'ResponsesDefinitions', '$visitor']);
+SecurityDefinitionsElement.refract = createRefractor(['visitors', 'document', 'objects', 'SecurityDefinitions', '$visitor']);
+SecuritySchemeElement.refract = createRefractor(['visitors', 'document', 'objects', 'SecurityScheme', '$visitor']);
+ScopesElement.refract = createRefractor(['visitors', 'document', 'objects', 'Scopes', '$visitor']);
+SecurityRequirementElement.refract = createRefractor(['visitors', 'document', 'objects', 'SecurityRequirement', '$visitor']);
+export { SwaggerElement, SwaggerVersionElement, InfoElement, ContactElement, LicenseElement, PathsElement, PathItemElement, OperationElement, ExternalDocumentationElement, ParameterElement, ItemsElement, ResponsesElement, ResponseElement, HeadersElement, ExampleElement, HeaderElement, TagElement, ReferenceElement, SchemaElement, XmlElement, DefinitionsElement, ParametersDefinitionsElement, ResponsesDefinitionsElement, SecurityDefinitionsElement, SecuritySchemeElement, ScopesElement, SecurityRequirementElement };