@swagger-api/apidom-ns-openapi-2 0.92.0 → 0.94.0

package/es/refractor/visitors/open-api-2/parameter/index.mjs

@@ -1,15 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import ParameterElement from "../../../../elements/Parameter.mjs";
-import FallbackVisitor from "../../FallbackVisitor.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
-const ParameterVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Parameter']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+class ParameterVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ParameterElement();
+    this.specPath = always(['document', 'objects', 'Parameter']);
+    this.canSupportSpecificationExtensions = true;
   }
-});
+}
 export default ParameterVisitor;

package/es/refractor/visitors/open-api-2/parameters-definitions/index.mjs

@@ -1,14 +1,13 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import ParametersDefinitionsElement from "../../../../elements/ParametersDefinitions.mjs";
 import MapVisitor from "../../generics/MapVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const ParametersDefinitionsVisitor = stampit(MapVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Parameter'])
-  },
-  init() {
+class ParametersDefinitionsVisitor extends Mixin(MapVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ParametersDefinitionsElement();
+    this.specPath = always(['document', 'objects', 'Parameter']);
   }
-});
+}
 export default ParametersDefinitionsVisitor;

package/es/refractor/visitors/open-api-2/path-item/$RefVisitor.mjs

@@ -1,13 +1,9 @@
-import stampit from 'stampit';
-import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const $RefVisitor = stampit(FallbackVisitor, {
-  methods: {
-    StringElement(stringElement) {
-      this.element = cloneDeep(stringElement);
-      this.element.classes.push('reference-value');
-      return BREAK;
-    }
+class $RefVisitor extends FallbackVisitor {
+  StringElement(stringElement) {
+    const result = super.enter(stringElement);
+    this.element.classes.push('reference-value');
+    return result;
   }
-});
+}
 export default $RefVisitor;

package/es/refractor/visitors/open-api-2/path-item/ParametersVisitor.mjs

@@ -1,27 +1,26 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { BREAK } from '@swagger-api/apidom-core';
 import { isReferenceLikeElement } from "../../../predicates.mjs";
 import { isReferenceElement } from "../../../../predicates.mjs";
 import PathItemParametersElement from "../../../../elements/nces/PathItemParameters.mjs";
-import FallbackVisitor from "../../FallbackVisitor.mjs";
 import SpecificationVisitor from "../../SpecificationVisitor.mjs";
-const ParametersVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
-  init() {
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+class ParametersVisitor extends Mixin(SpecificationVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new PathItemParametersElement();
-  },
-  methods: {
-    ArrayElement(arrayElement) {
-      arrayElement.forEach(item => {
-        const specPath = isReferenceLikeElement(item) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Parameter'];
-        const element = this.toRefractedElement(specPath, item);
-        if (isReferenceElement(element)) {
-          element.setMetaProperty('referenced-element', 'parameter');
-        }
-        this.element.push(element);
-      });
-      this.copyMetaAndAttributes(arrayElement, this.element);
-      return BREAK;
-    }
   }
-});
+  ArrayElement(arrayElement) {
+    arrayElement.forEach(item => {
+      const specPath = isReferenceLikeElement(item) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Parameter'];
+      const element = this.toRefractedElement(specPath, item);
+      if (isReferenceElement(element)) {
+        element.setMetaProperty('referenced-element', 'parameter');
+      }
+      this.element.push(element);
+    });
+    this.copyMetaAndAttributes(arrayElement, this.element);
+    return BREAK;
+  }
+}
 export default ParametersVisitor;

package/es/refractor/visitors/open-api-2/path-item/index.mjs

@@ -1,35 +1,33 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import { isStringElement, cloneDeep, toValue } from '@swagger-api/apidom-core';
 import PathItemElement from "../../../../elements/PathItem.mjs";
 import { isOperationElement } from "../../../../predicates.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const PathItemVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'PathItem'])
-  },
-  init() {
+class PathItemVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new PathItemElement();
-  },
-  methods: {
-    ObjectElement(objectElement) {
-      // @ts-ignore
-      const result = FixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+    this.specPath = always(['document', 'objects', 'PathItem']);
+  }
+  ObjectElement(objectElement) {
+    const result = FixedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
 
-      // decorate Operation elements with HTTP method
-      this.element.filter(isOperationElement).forEach((operationElement, httpMethodElementCI) => {
-        const httpMethodElementCS = cloneDeep(httpMethodElementCI);
-        httpMethodElementCS.content = toValue(httpMethodElementCS).toUpperCase();
-        operationElement.setMetaProperty('http-method', httpMethodElementCS);
-      });
+    // decorate Operation elements with HTTP method
+    this.element.filter(isOperationElement)
+    // @ts-ignore
+    .forEach((operationElement, httpMethodElementCI) => {
+      const httpMethodElementCS = cloneDeep(httpMethodElementCI);
+      httpMethodElementCS.content = toValue(httpMethodElementCS).toUpperCase();
+      operationElement.setMetaProperty('http-method', httpMethodElementCS);
+    });
 
-      // mark this PathItemElement with reference metadata
-      if (isStringElement(this.element.$ref)) {
-        this.element.classes.push('reference-element');
-      }
-      return result;
+    // mark this PathItemElement with reference metadata
+    if (isStringElement(this.element.$ref)) {
+      this.element.classes.push('reference-element');
     }
+    return result;
   }
-});
+}
 export default PathItemVisitor;

package/es/refractor/visitors/open-api-2/paths/index.mjs

@@ -1,32 +1,31 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { T as stubTrue, always } from 'ramda';
 import { cloneDeep } from '@swagger-api/apidom-core';
 import PathsElement from "../../../../elements/Paths.mjs";
 import PatternedFieldsVisitor from "../../generics/PatternedFieldsVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
 import { isPathItemElement } from "../../../../predicates.mjs";
-const PathsVisitor = stampit(PatternedFieldsVisitor, FallbackVisitor, {
-  props: {
-    fieldPatternPredicate: stubTrue,
-    specPath: always(['document', 'objects', 'PathItem']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+class PathsVisitor extends Mixin(PatternedFieldsVisitor, FallbackVisitor) {
+  element;
+  constructor(options) {
+    super(options);
     this.element = new PathsElement();
-  },
-  methods: {
-    ObjectElement(objectElement) {
-      // @ts-ignore
-      const result = PatternedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+    this.specPath = always(['document', 'objects', 'PathItem']);
+    this.canSupportSpecificationExtensions = true;
+    this.fieldPatternPredicate = stubTrue;
+  }
+  ObjectElement(objectElement) {
+    const result = PatternedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
 
-      // decorate every PathItemElement with path metadata
-      this.element.filter(isPathItemElement).forEach((pathItemElement, key) => {
-        key.classes.push('openapi-path-template');
-        key.classes.push('path-template');
-        pathItemElement.setMetaProperty('path', cloneDeep(key));
-      });
-      return result;
-    }
+    // decorate every PathItemElement with path metadata
+    this.element.filter(isPathItemElement)
+    // @ts-ignore
+    .forEach((pathItemElement, key) => {
+      key.classes.push('openapi-path-template');
+      key.classes.push('path-template');
+      pathItemElement.setMetaProperty('path', cloneDeep(key));
+    });
+    return result;
   }
-});
+}
 export default PathsVisitor;

package/es/refractor/visitors/open-api-2/reference/$RefVisitor.mjs

@@ -1,13 +1,9 @@
-import stampit from 'stampit';
-import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const $RefVisitor = stampit(FallbackVisitor, {
-  methods: {
-    StringElement(stringElement) {
-      this.element = cloneDeep(stringElement);
-      this.element.classes.push('reference-value');
-      return BREAK;
-    }
+class $RefVisitor extends FallbackVisitor {
+  StringElement(stringElement) {
+    const result = super.enter(stringElement);
+    this.element.classes.push('reference-value');
+    return result;
   }
-});
+}
 export default $RefVisitor;

package/es/refractor/visitors/open-api-2/reference/index.mjs

@@ -1,28 +1,24 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import { isStringElement } from '@swagger-api/apidom-core';
 import ReferenceElement from "../../../../elements/Reference.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const ReferenceVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Reference']),
-    canSupportSpecificationExtensions: false
-  },
-  init() {
+class ReferenceVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ReferenceElement();
-  },
-  methods: {
-    ObjectElement(objectElement) {
-      // @ts-ignore
-      const result = FixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+    this.specPath = always(['document', 'objects', 'Reference']);
+    this.canSupportSpecificationExtensions = false;
+  }
+  ObjectElement(objectElement) {
+    const result = FixedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
 
-      // mark this ReferenceElement with reference metadata
-      if (isStringElement(this.element.$ref)) {
-        this.element.classes.push('reference-element');
-      }
-      return result;
+    // mark this ReferenceElement with reference metadata
+    if (isStringElement(this.element.$ref)) {
+      this.element.classes.push('reference-element');
     }
+    return result;
   }
-});
+}
 export default ReferenceVisitor;

package/es/refractor/visitors/open-api-2/response/index.mjs

@@ -1,15 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import ResponseElement from "../../../../elements/Response.mjs";
-import FallbackVisitor from "../../FallbackVisitor.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
-const ResponseVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Response']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+class ResponseVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ResponseElement();
+    this.specPath = always(['document', 'objects', 'Response']);
+    this.canSupportSpecificationExtensions = true;
   }
-});
+}
 export default ResponseVisitor;

package/es/refractor/visitors/open-api-2/responses/DefaultVisitor.mjs

@@ -1,32 +1,30 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { T as stubTrue } from 'ramda';
 import { isReferenceLikeElement } from "../../../predicates.mjs";
 import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
 import AlternatingVisitor from "../../generics/AlternatingVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const DefaultVisitor = stampit(AlternatingVisitor, FallbackVisitor, {
-  props: {
-    alternator: [{
+class DefaultVisitor extends Mixin(AlternatingVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
+    this.alternator = [{
       predicate: isReferenceLikeElement,
       specPath: ['document', 'objects', 'Reference']
     }, {
       predicate: stubTrue,
       specPath: ['document', 'objects', 'Response']
-    }]
-  },
-  methods: {
-    ObjectElement(objectElement) {
-      // @ts-ignore
-      const result = AlternatingVisitor.compose.methods.enter.call(this, objectElement);
+    }];
+  }
+  ObjectElement(objectElement) {
+    const result = AlternatingVisitor.prototype.enter.call(this, objectElement);
 
-      // decorate ReferenceElement with type of referencing element
-      if (isReferenceElement(this.element)) {
-        this.element.setMetaProperty('referenced-element', 'response');
-      } else if (isResponseElement(this.element)) {
-        this.element.setMetaProperty('http-status-code', 'default');
-      }
-      return result;
+    // decorate ReferenceElement with type of referencing element
+    if (isReferenceElement(this.element)) {
+      this.element.setMetaProperty('referenced-element', 'response');
+    } else if (isResponseElement(this.element)) {
+      this.element.setMetaProperty('http-status-code', 'default');
     }
+    return result;
   }
-});
+}
 export default DefaultVisitor;

package/es/refractor/visitors/open-api-2/responses/index.mjs

@@ -1,4 +1,4 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { test, always, range } from 'ramda';
 import { cloneDeep, toValue } from '@swagger-api/apidom-core';
 import ResponsesElement from "../../../../elements/Responses.mjs";
@@ -6,36 +6,35 @@ import MixedFieldsVisitor from "../../generics/MixedFieldsVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
 import { isReferenceLikeElement } from "../../../predicates.mjs";
 import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
-const ResponsesVisitor = stampit(MixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPathFixedFields: always(['document', 'objects', 'Responses']),
-    specPathPatternedFields: element => {
-      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Response'];
-    },
-    fieldPatternPredicate: test(new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${range(100, 600).join('|')})$`)),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+class ResponsesVisitor extends Mixin(MixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ResponsesElement();
-  },
-  methods: {
-    ObjectElement(objectElement) {
-      // @ts-ignore
-      const result = MixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+    this.specPathFixedFields = always(['document', 'objects', 'Responses']);
+    this.canSupportSpecificationExtensions = true;
+    this.specPathPatternedFields = element => {
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Response'];
+    };
+    // @ts-ignore
+    this.fieldPatternPredicate = test(new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${range(100, 600).join('|')})$`));
+  }
+  ObjectElement(objectElement) {
+    const result = MixedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
 
-      // decorate every ReferenceElement with metadata about their referencing type
-      this.element.filter(isReferenceElement).forEach(referenceElement => {
-        referenceElement.setMetaProperty('referenced-element', 'response');
-      });
+    // decorate every ReferenceElement with metadata about their referencing type
+    // @ts-ignore
+    this.element.filter(isReferenceElement).forEach(referenceElement => {
+      referenceElement.setMetaProperty('referenced-element', 'response');
+    });
 
-      // decorate every ResponseElement with metadata about their status code
-      this.element.filter(isResponseElement).forEach((value, key) => {
-        const httpStatusCode = cloneDeep(key);
-        if (!this.fieldPatternPredicate(toValue(httpStatusCode))) return;
-        value.setMetaProperty('http-status-code', httpStatusCode);
-      });
-      return result;
-    }
+    // decorate every ResponseElement with metadata about their status code
+    // @ts-ignore
+    this.element.filter(isResponseElement).forEach((value, key) => {
+      const httpStatusCode = cloneDeep(key);
+      if (!this.fieldPatternPredicate(toValue(httpStatusCode))) return;
+      value.setMetaProperty('http-status-code', httpStatusCode);
+    });
+    return result;
   }
-});
+}
 export default ResponsesVisitor;

package/es/refractor/visitors/open-api-2/responses-definitions/index.mjs

@@ -1,14 +1,13 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import ResponsesDefinitionsElement from "../../../../elements/ResponsesDefinitions.mjs";
 import MapVisitor from "../../generics/MapVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const ResponsesDefinitionsVisitor = stampit(MapVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Response'])
-  },
-  init() {
+class ResponsesDefinitionsVisitor extends Mixin(MapVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ResponsesDefinitionsElement();
+    this.specPath = always(['document', 'objects', 'Response']);
   }
-});
+}
 export default ResponsesDefinitionsVisitor;

package/es/refractor/visitors/open-api-2/schema/AllOfVisitor.mjs

@@ -1,9 +1,8 @@
-import stampit from 'stampit';
 import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 const {
   allOf: JSONSchemaAllOfVisitor
 } = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
-const AllOfVisitor = stampit(JSONSchemaAllOfVisitor, {
+const AllOfVisitor = JSONSchemaAllOfVisitor.compose({
   methods: {
     ArrayElement(arrayElement) {
       // @ts-ignore

package/es/refractor/visitors/open-api-2/schema/ItemsVisitor.mjs

@@ -1,9 +1,8 @@
-import stampit from 'stampit';
 import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 const {
   items: JSONSchemaItemsVisitor
 } = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
-const ItemsVisitor = stampit(JSONSchemaItemsVisitor, {
+const ItemsVisitor = JSONSchemaItemsVisitor.compose({
   methods: {
     ObjectElement(objectElement) {
       // @ts-ignore

package/es/refractor/visitors/open-api-2/schema/PropertiesVisitor.mjs

@@ -1,9 +1,8 @@
-import stampit from 'stampit';
 import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 const {
   properties: JSONSchemaPropertiesVisitor
 } = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
-const PropertiesVisitor = stampit(JSONSchemaPropertiesVisitor, {
+const PropertiesVisitor = JSONSchemaPropertiesVisitor.compose({
   methods: {
     ObjectElement(objectElement) {
       // @ts-ignore

package/es/refractor/visitors/open-api-2/schema/SchemaOrJSONReferenceVisitor.mjs

@@ -1,9 +1,8 @@
-import stampit from 'stampit';
 import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 const {
   JSONSchemaOrJSONReferenceVisitor
 } = JSONSchemaDraft4Specification.visitors;
-const SchemaOrJSONReferenceVisitor = stampit(JSONSchemaOrJSONReferenceVisitor, {
+const SchemaOrJSONReferenceVisitor = JSONSchemaOrJSONReferenceVisitor.compose({
   methods: {
     ObjectElement(objectElement) {
       // @ts-ignore

package/es/refractor/visitors/open-api-2/schema/index.mjs

@@ -1,15 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import SchemaElement from "../../../../elements/Schema.mjs";
-import FallbackVisitor from "../../FallbackVisitor.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
-const SchemaVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'Schema']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+class SchemaVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new SchemaElement();
+    this.specPath = always(['document', 'objects', 'Schema']);
+    this.canSupportSpecificationExtensions = true;
   }
-});
+}
 export default SchemaVisitor;

package/es/refractor/visitors/open-api-2/scopes/index.mjs

@@ -1,15 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import ScopesElement from "../../../../elements/Scopes.mjs";
 import MapVisitor from "../../generics/MapVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const ScopesVisitor = stampit(MapVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['value']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+class ScopesVisitor extends Mixin(MapVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new ScopesElement();
+    this.specPath = always(['value']);
+    this.canSupportSpecificationExtensions = true;
   }
-});
+}
 export default ScopesVisitor;

package/es/refractor/visitors/open-api-2/security-definitions/index.mjs

@@ -1,14 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import SecurityDefinitionsElement from "../../../../elements/SecurityDefinitions.mjs";
 import MapVisitor from "../../generics/MapVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const SecurityDefinitionsVisitor = stampit(MapVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'SecurityScheme'])
-  },
-  init() {
+class SecurityDefinitionsVisitor extends Mixin(MapVisitor, FallbackVisitor) {
+  element;
+  constructor(options) {
+    super(options);
     this.element = new SecurityDefinitionsElement();
+    this.specPath = always(['document', 'objects', 'SecurityScheme']);
   }
-});
+}
 export default SecurityDefinitionsVisitor;

package/es/refractor/visitors/open-api-2/security-requirement/index.mjs

@@ -1,14 +1,13 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import SecurityRequirementElement from "../../../../elements/SecurityRequirement.mjs";
 import MapVisitor from "../../generics/MapVisitor.mjs";
 import FallbackVisitor from "../../FallbackVisitor.mjs";
-const SecurityRequirementVisitor = stampit(MapVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['value'])
-  },
-  init() {
+class SecurityRequirementVisitor extends Mixin(MapVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new SecurityRequirementElement();
+    this.specPath = always(['value']);
   }
-});
+}
 export default SecurityRequirementVisitor;

package/es/refractor/visitors/open-api-2/security-scheme/index.mjs

@@ -1,15 +1,14 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { always } from 'ramda';
 import SecuritySchemeElement from "../../../../elements/SecurityScheme.mjs";
-import FallbackVisitor from "../../FallbackVisitor.mjs";
 import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
-const SecuritySchemeVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
-  props: {
-    specPath: always(['document', 'objects', 'SecurityScheme']),
-    canSupportSpecificationExtensions: true
-  },
-  init() {
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+class SecuritySchemeVisitor extends Mixin(FixedFieldsVisitor, FallbackVisitor) {
+  constructor(options) {
+    super(options);
     this.element = new SecuritySchemeElement();
+    this.specPath = always(['document', 'objects', 'SecurityScheme']);
+    this.canSupportSpecificationExtensions = true;
   }
-});
+}
 export default SecuritySchemeVisitor;