swagger-client 3.36.2 → 3.37.1

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/visitors/parameters.js

@@ -0,0 +1,40 @@
+import { toValue } from '@swagger-api/apidom-core';
+import toPath from '../utils/to-path.js';
+class ParameterMacroVisitor {
+  parameterMacro;
+  options;
+  #macroOperation;
+  OperationElement = {
+    enter: operationElement => {
+      this.#macroOperation = operationElement;
+    },
+    leave: () => {
+      this.#macroOperation = undefined;
+    }
+  };
+  ParameterElement = {
+    leave: (parameterElement, key, parent, path, ancestors) => {
+      const pojoOperation = this.#macroOperation ? toValue(this.#macroOperation) : null;
+      const pojoParameter = toValue(parameterElement);
+      try {
+        const macroValue = this.parameterMacro(pojoOperation, pojoParameter);
+        parameterElement.set('default', macroValue);
+      } catch (error) {
+        var _this$options$derefer, _this$options$derefer2;
+        const macroError = new Error(error, {
+          cause: error
+        });
+        macroError.fullPath = toPath([...ancestors, parent]);
+        (_this$options$derefer = this.options.dereference.dereferenceOpts) === null || _this$options$derefer === void 0 || (_this$options$derefer = _this$options$derefer.errors) === null || _this$options$derefer === void 0 || (_this$options$derefer2 = _this$options$derefer.push) === null || _this$options$derefer2 === void 0 || _this$options$derefer2.call(_this$options$derefer, macroError);
+      }
+    }
+  };
+  constructor({
+    parameterMacro,
+    options
+  }) {
+    this.parameterMacro = parameterMacro;
+    this.options = options;
+  }
+}
+export default ParameterMacroVisitor;

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/visitors/properties.js

@@ -0,0 +1,34 @@
+import { isObjectElement, toValue } from '@swagger-api/apidom-core';
+import toPath from '../utils/to-path.js';
+class ModelPropertyMacroVisitor {
+  modelPropertyMacro;
+  options;
+  SchemaElement = {
+    leave: (schemaElement, key, parent, path, ancestors) => {
+      if (typeof schemaElement.properties === 'undefined') return;
+      if (!isObjectElement(schemaElement.properties)) return;
+      schemaElement.properties.forEach(property => {
+        if (!isObjectElement(property)) return;
+        try {
+          const macroValue = this.modelPropertyMacro(toValue(property));
+          property.set('default', macroValue);
+        } catch (error) {
+          var _this$options$derefer, _this$options$derefer2;
+          const macroError = new Error(error, {
+            cause: error
+          });
+          macroError.fullPath = [...toPath([...ancestors, parent, schemaElement]), 'properties'];
+          (_this$options$derefer = this.options.dereference.dereferenceOpts) === null || _this$options$derefer === void 0 || (_this$options$derefer = _this$options$derefer.errors) === null || _this$options$derefer === void 0 || (_this$options$derefer2 = _this$options$derefer.push) === null || _this$options$derefer2 === void 0 || _this$options$derefer2.call(_this$options$derefer, macroError);
+        }
+      });
+    }
+  };
+  constructor({
+    modelPropertyMacro,
+    options
+  }) {
+    this.modelPropertyMacro = modelPropertyMacro;
+    this.options = options;
+  }
+}
+export default ModelPropertyMacroVisitor;

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/visitors/root.js

@@ -0,0 +1,45 @@
+import { mergeAllVisitors } from '@swagger-api/apidom-core';
+import { getNodeType } from '@swagger-api/apidom-ns-openapi-3-2';
+import ModelPropertyMacroVisitor from './properties.js';
+import AllOfVisitor from './all-of.js';
+import ParameterMacroVisitor from './parameters.js';
+import OpenAPI3_2SwaggerClientDereferenceVisitor from './dereference.js'; // eslint-disable-line camelcase
+
+const mergeAllVisitorsAsync = mergeAllVisitors[Symbol.for('nodejs.util.promisify.custom')];
+class RootVisitor {
+  constructor({
+    parameterMacro,
+    modelPropertyMacro,
+    mode,
+    options,
+    ...rest
+  }) {
+    const visitors = [];
+    visitors.push(new OpenAPI3_2SwaggerClientDereferenceVisitor({
+      ...rest,
+      options
+    }));
+    if (typeof modelPropertyMacro === 'function') {
+      visitors.push(new ModelPropertyMacroVisitor({
+        modelPropertyMacro,
+        options
+      }));
+    }
+    if (mode !== 'strict') {
+      visitors.push(new AllOfVisitor({
+        options
+      }));
+    }
+    if (typeof parameterMacro === 'function') {
+      visitors.push(new ParameterMacroVisitor({
+        parameterMacro,
+        options
+      }));
+    }
+    const mergedVisitor = mergeAllVisitorsAsync(visitors, {
+      nodeTypeGetter: getNodeType
+    });
+    Object.assign(this, mergedVisitor);
+  }
+}
+export default RootVisitor;

package/es/resolver/apidom/reference/parse/parsers/openapi-json-3-2/index.js

@@ -0,0 +1,55 @@
+/* eslint-disable camelcase */
+import { ParseResultElement } from '@swagger-api/apidom-core';
+import { ParserError, Parser } from '@swagger-api/apidom-reference/configuration/empty';
+import { mediaTypes, OpenApi3_2Element, OpenAPIMediaTypes } from '@swagger-api/apidom-ns-openapi-3-2';
+class OpenAPIJSON3_2Parser extends Parser {
+  detectionRegExp = /"openapi"\s*:\s*"(?<version_json>3\.2\.(?:[1-9]\d*|0))"/;
+  constructor(options = {}) {
+    super({
+      name: 'openapi-json-3-2-swagger-client',
+      mediaTypes: new OpenAPIMediaTypes(...mediaTypes.filterByFormat('generic'), ...mediaTypes.filterByFormat('json')),
+      ...options
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      try {
+        const source = file.toString();
+        JSON.parse(source);
+        return this.detectionRegExp.test(source);
+      } catch (error) {
+        return false;
+      }
+    }
+    return false;
+  }
+  async parse(file) {
+    if (this.sourceMap) {
+      throw new ParserError("openapi-json-3-2-swagger-client parser plugin doesn't support sourceMaps option");
+    }
+    const parseResultElement = new ParseResultElement();
+    const source = file.toString();
+
+    // allow empty files
+    if (this.allowEmpty && source.trim() === '') {
+      return parseResultElement;
+    }
+    try {
+      const pojo = JSON.parse(source);
+      const element = OpenApi3_2Element.refract(pojo, this.refractorOpts);
+      element.classes.push('result');
+      parseResultElement.push(element);
+      return parseResultElement;
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default OpenAPIJSON3_2Parser;
+/* eslint-enable camelcase */

package/es/resolver/apidom/reference/parse/parsers/openapi-yaml-3-2/index.js

@@ -0,0 +1,56 @@
+/* eslint-disable camelcase */
+import YAML, { JSON_SCHEMA } from 'js-yaml';
+import { ParseResultElement } from '@swagger-api/apidom-core';
+import { ParserError, Parser } from '@swagger-api/apidom-reference/configuration/empty';
+import { mediaTypes, OpenApi3_2Element, OpenAPIMediaTypes } from '@swagger-api/apidom-ns-openapi-3-2';
+class OpenAPIYAML32Parser extends Parser {
+  detectionRegExp = /(?<YAML>^(["']?)openapi\2\s*:\s*(["']?)(?<version_yaml>3\.2\.(?:[1-9]\d*|0))\3(?:\s+|$))|(?<JSON>"openapi"\s*:\s*"(?<version_json>3\.2\.(?:[1-9]\d*|0))")/m;
+  constructor(options = {}) {
+    super({
+      name: 'openapi-yaml-3-2-swagger-client',
+      mediaTypes: new OpenAPIMediaTypes(...mediaTypes.filterByFormat('generic'), ...mediaTypes.filterByFormat('yaml')),
+      ...options
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      try {
+        const source = file.toString();
+        YAML.load(source);
+        return this.detectionRegExp.test(source);
+      } catch (error) {
+        return false;
+      }
+    }
+    return false;
+  }
+  async parse(file) {
+    if (this.sourceMap) {
+      throw new ParserError("openapi-yaml-3-2-swagger-client parser plugin doesn't support sourceMaps option");
+    }
+    const parseResultElement = new ParseResultElement();
+    const source = file.toString();
+    try {
+      const pojo = YAML.load(source, {
+        schema: JSON_SCHEMA
+      });
+      if (this.allowEmpty && typeof pojo === 'undefined') {
+        return parseResultElement;
+      }
+      const element = OpenApi3_2Element.refract(pojo, this.refractorOpts);
+      element.classes.push('result');
+      parseResultElement.push(element);
+      return parseResultElement;
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default OpenAPIYAML32Parser;
+/* eslint-enable camelcase */

package/es/resolver/strategies/openapi-3-2-apidom/index.js

@@ -0,0 +1,28 @@
+import { isPlainObject } from 'ramda-adjunct';
+import { isElement } from '@swagger-api/apidom-core';
+import resolveOpenAPI32Strategy from './resolve.js';
+import normalize, { pojoAdapter } from './normalize.js';
+import { isOpenAPI32 } from '../../../helpers/openapi-predicates.js';
+const openApi32ApiDOMStrategy = {
+  name: 'openapi-3-2-apidom',
+  match(spec) {
+    return isOpenAPI32(spec);
+  },
+  normalize(spec) {
+    // pre-normalization - happens only once before the first lazy dereferencing and in JavaScript context
+    if (!isElement(spec) && isPlainObject(spec) && !spec.$$normalized) {
+      const preNormalized = pojoAdapter(normalize)(spec);
+      preNormalized.$$normalized = true;
+      return preNormalized;
+    }
+    // post-normalization - happens after each dereferencing and in ApiDOM context
+    if (isElement(spec)) {
+      return normalize(spec);
+    }
+    return spec;
+  },
+  async resolve(options) {
+    return resolveOpenAPI32Strategy(options);
+  }
+};
+export default openApi32ApiDOMStrategy;

package/es/resolver/strategies/openapi-3-2-apidom/normalize.js

@@ -0,0 +1,44 @@
+/* eslint-disable camelcase */
+import { dispatchRefractorPlugins, isObjectElement, toValue } from '@swagger-api/apidom-core';
+import { refractorPluginNormalizeOperationIds, refractorPluginNormalizeParameters, refractorPluginNormalizeSecurityRequirements, refractorPluginNormalizeParameterExamples, refractorPluginNormalizeHeaderExamples, createToolbox, keyMap, getNodeType, OpenApi3_2Element } from '@swagger-api/apidom-ns-openapi-3-2';
+import opId from '../../../helpers/op-id.js';
+import resolveOpenAPI32Strategy from './resolve.js';
+const normalize = element => {
+  if (!isObjectElement(element)) return element;
+  const plugins = [refractorPluginNormalizeOperationIds({
+    operationIdNormalizer: (operationId, path, method) => opId({
+      operationId
+    }, path, method, {
+      v2OperationIdCompatibilityMode: false
+    })
+  }), refractorPluginNormalizeParameters(), refractorPluginNormalizeSecurityRequirements(), refractorPluginNormalizeParameterExamples(), refractorPluginNormalizeHeaderExamples()];
+  const normalized = dispatchRefractorPlugins(element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      keyMap,
+      nodeTypeGetter: getNodeType
+    }
+  });
+  return normalized;
+};
+
+/**
+ * This adapter allow to perform normalization on Plain Old JavaScript Objects.
+ * The function adapts the `normalize` function interface and is able to accept
+ * Plain Old JavaScript Objects and returns Plain Old JavaScript Objects.
+ */
+export const pojoAdapter = normalizeFn => spec => {
+  const openApiElement = OpenApi3_2Element.refract(spec);
+  openApiElement.classes.push('result');
+  const normalized = normalizeFn(openApiElement);
+  const value = toValue(normalized);
+
+  /**
+   * We're setting the cache here to avoid repeated refracting
+   * in `openapi-3-2-apidom` strategy resolve method.
+   */
+  resolveOpenAPI32Strategy.cache.set(value, normalized);
+  return toValue(normalized);
+};
+export default normalize;
+/* eslint-enable camelcase */

package/es/resolver/strategies/openapi-3-2-apidom/resolve.js

@@ -0,0 +1,161 @@
+/* eslint-disable camelcase */
+import { ParseResultElement, ObjectElement, toValue, transclude, cloneDeep } from '@swagger-api/apidom-core';
+import { compile as jsonPointerCompile, evaluate as jsonPointerEvaluate, JSONPointerEvaluateError } from '@swagger-api/apidom-json-pointer/modern';
+import { mediaTypes, OpenApi3_2Element } from '@swagger-api/apidom-ns-openapi-3-2';
+import { dereferenceApiDOM, url, ReferenceSet, Reference, options as referenceOptions } from '@swagger-api/apidom-reference/configuration/empty';
+import BinaryParser from '@swagger-api/apidom-reference/parse/parsers/binary';
+import OpenAPI3_1ResolveStrategy from '@swagger-api/apidom-reference/resolve/strategies/openapi-3-1';
+import { DEFAULT_BASE_URL } from '../../../constants.js';
+import * as optionsUtil from '../../utils/options.js';
+import HTTPResolverSwaggerClient from '../../apidom/reference/resolve/resolvers/http-swagger-client/index.js';
+import JSONParser from '../../apidom/reference/parse/parsers/json/index.js';
+import YAMLParser from '../../apidom/reference/parse/parsers/yaml-1-2/index.js';
+import OpenAPIJSON3_2Parser from '../../apidom/reference/parse/parsers/openapi-json-3-2/index.js';
+import OpenAPIYAML3_2Parser from '../../apidom/reference/parse/parsers/openapi-yaml-3-2/index.js';
+import OpenAPI3_2SwaggerClientDereferenceStrategy from '../../apidom/reference/dereference/strategies/openapi-3-2-swagger-client/index.js';
+export const circularReplacer = refElement => {
+  const $refBaseURI = toValue(refElement.meta.get('baseURI'));
+  const referencingElement = refElement.meta.get('referencingElement');
+
+  /**
+   * Removing semantics from the absolutified referencing element by
+   * using generic ObjectElement to represent the reference.
+   */
+  return new ObjectElement({
+    $ref: $refBaseURI
+  }, cloneDeep(referencingElement.meta), cloneDeep(referencingElement.attributes));
+};
+const resolveOpenAPI32Strategy = async options => {
+  const {
+    spec,
+    timeout,
+    redirects,
+    requestInterceptor,
+    responseInterceptor,
+    pathDiscriminator = [],
+    allowMetaPatches = false,
+    useCircularStructures = false,
+    skipNormalization = false,
+    parameterMacro = null,
+    modelPropertyMacro = null,
+    mode = 'non-strict',
+    strategies
+  } = options;
+  try {
+    const {
+      cache
+    } = resolveOpenAPI32Strategy;
+    const strategy = strategies.find(strg => strg.match(spec));
+
+    // determining BaseURI
+    const cwd = url.isHttpUrl(url.cwd()) ? url.cwd() : DEFAULT_BASE_URL;
+    const retrievalURI = optionsUtil.retrievalURI(options);
+    const baseURI = url.resolve(cwd, retrievalURI);
+
+    // prepare spec for dereferencing
+    let openApiElement;
+    if (cache.has(spec)) {
+      openApiElement = cache.get(spec);
+    } else {
+      openApiElement = OpenApi3_2Element.refract(spec);
+      openApiElement.classes.push('result');
+      cache.set(spec, openApiElement);
+    }
+    const openApiParseResultElement = new ParseResultElement([openApiElement]);
+
+    // prepare fragment for dereferencing
+    const jsonPointer = jsonPointerCompile(pathDiscriminator);
+    const jsonPointerURI = jsonPointer === '' ? '' : `#${jsonPointer}`;
+    const fragmentElement = jsonPointerEvaluate(openApiElement, jsonPointer);
+
+    // prepare reference set for dereferencing
+    const openApiElementReference = new Reference({
+      uri: baseURI,
+      value: openApiParseResultElement
+    });
+    const refSet = new ReferenceSet({
+      refs: [openApiElementReference]
+    });
+    if (jsonPointer !== '') refSet.rootRef = undefined; // reset root reference as we want fragment to become the root reference
+
+    // prepare ancestors; needed for cases where fragment is not OpenAPI element
+    const ancestors = [new Set([fragmentElement])];
+    const errors = [];
+    const dereferenced = await dereferenceApiDOM(fragmentElement, {
+      resolve: {
+        /**
+         * swagger-client only supports resolving HTTP(S) URLs or spec objects.
+         * If runtime env is detected as non-browser one,
+         * and baseURI was not provided as part of resolver options,
+         * then below baseURI check will make sure that constant HTTPS URL is used as baseURI.
+         */
+        baseURI: `${baseURI}${jsonPointerURI}`,
+        resolvers: [new HTTPResolverSwaggerClient({
+          timeout: timeout || 10000,
+          redirects: redirects || 10
+        })],
+        resolverOpts: {
+          swaggerHTTPClientConfig: {
+            requestInterceptor,
+            responseInterceptor
+          }
+        },
+        strategies: [new OpenAPI3_1ResolveStrategy()]
+      },
+      parse: {
+        mediaType: mediaTypes.latest(),
+        parsers: [new OpenAPIJSON3_2Parser({
+          allowEmpty: false,
+          sourceMap: false
+        }), new OpenAPIYAML3_2Parser({
+          allowEmpty: false,
+          sourceMap: false
+        }), new JSONParser({
+          allowEmpty: false,
+          sourceMap: false
+        }), new YAMLParser({
+          allowEmpty: false,
+          sourceMap: false
+        }), new BinaryParser({
+          allowEmpty: false,
+          sourceMap: false
+        })]
+      },
+      dereference: {
+        maxDepth: 100,
+        strategies: [new OpenAPI3_2SwaggerClientDereferenceStrategy({
+          allowMetaPatches,
+          useCircularStructures,
+          parameterMacro,
+          modelPropertyMacro,
+          mode,
+          ancestors
+        })],
+        refSet,
+        dereferenceOpts: {
+          errors
+        },
+        immutable: false,
+        circular: useCircularStructures ? 'ignore' : 'replace',
+        circularReplacer: useCircularStructures ? referenceOptions.dereference.circularReplacer : circularReplacer
+      }
+    });
+    const transcluded = transclude(fragmentElement, dereferenced, openApiElement);
+    const normalized = skipNormalization ? transcluded : strategy.normalize(transcluded);
+    return {
+      spec: toValue(normalized),
+      errors
+    };
+  } catch (error) {
+    if (error instanceof JSONPointerEvaluateError) {
+      return {
+        spec,
+        errors: []
+      };
+    }
+    throw error;
+  }
+};
+resolveOpenAPI32Strategy.cache = new WeakMap();
+export default resolveOpenAPI32Strategy;
+/* eslint-enable camelcase */

package/lib/helpers/openapi-predicates.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.isSwagger2 = exports.isOpenAPI31 = exports.isOpenAPI30 = exports.isOpenAPI3 = exports.isOpenAPI2 = void 0;
+exports.isSwagger2 = exports.isOpenAPI32 = exports.isOpenAPI31 = exports.isOpenAPI30 = exports.isOpenAPI3 = exports.isOpenAPI2 = void 0;
 const isOpenAPI2 = spec => {
   try {
     const {
@@ -35,7 +35,18 @@ const isOpenAPI31 = spec => {
   }
 };
 exports.isOpenAPI31 = isOpenAPI31;
-const isOpenAPI3 = spec => isOpenAPI30(spec) || isOpenAPI31(spec);
+const isOpenAPI32 = spec => {
+  try {
+    const {
+      openapi
+    } = spec;
+    return typeof openapi === 'string' && /^3\.2\.(?:[1-9]\d*|0)$/.test(openapi);
+  } catch {
+    return false;
+  }
+};
+exports.isOpenAPI32 = isOpenAPI32;
+const isOpenAPI3 = spec => isOpenAPI30(spec) || isOpenAPI31(spec) || isOpenAPI32(spec);
 
 // backward compatibility export
 exports.isOpenAPI3 = isOpenAPI3;

package/lib/index.js

@@ -13,59 +13,67 @@ var _index5 = _interopRequireDefault(require("./resolver/strategies/generic/inde
 var _index6 = _interopRequireWildcard(require("./resolver/strategies/openapi-2/index.js"));
 var _index7 = _interopRequireDefault(require("./resolver/strategies/openapi-3-0/index.js"));
 var _index8 = _interopRequireDefault(require("./resolver/strategies/openapi-3-1-apidom/index.js"));
+var _index9 = _interopRequireDefault(require("./resolver/strategies/openapi-3-2-apidom/index.js"));
 var _interfaces = require("./interfaces.js");
-var _index9 = require("./execute/index.js");
-var _index0 = require("./helpers/index.js");
+var _index0 = require("./execute/index.js");
+var _index1 = require("./helpers/index.js");
 var _openapiPredicates = require("./helpers/openapi-predicates.js");
-var _index1 = _interopRequireDefault(require("./resolver/apidom/reference/resolve/resolvers/http-swagger-client/index.js"));
-var _index10 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/json/index.js"));
-var _index11 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/yaml-1-2/index.js"));
-var _index12 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-json-3-1/index.js"));
-var _index13 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-yaml-3-1/index.js"));
-var _index14 = _interopRequireDefault(require("./resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/index.js"));
+var _index10 = _interopRequireDefault(require("./resolver/apidom/reference/resolve/resolvers/http-swagger-client/index.js"));
+var _index11 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/json/index.js"));
+var _index12 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/yaml-1-2/index.js"));
+var _index13 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-json-3-1/index.js"));
+var _index14 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-yaml-3-1/index.js"));
+var _index15 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-json-3-2/index.js"));
+var _index16 = _interopRequireDefault(require("./resolver/apidom/reference/parse/parsers/openapi-yaml-3-2/index.js"));
+var _index17 = _interopRequireDefault(require("./resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/index.js"));
+var _index18 = _interopRequireDefault(require("./resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/index.js"));
 /* eslint-disable camelcase */
 
 Swagger.http = _index.default;
 Swagger.makeHttp = _index.makeHttp.bind(null, Swagger.http);
 Swagger.resolveStrategies = {
+  'openapi-3-2-apidom': _index9.default,
   'openapi-3-1-apidom': _index8.default,
   'openapi-3-0': _index7.default,
   'openapi-2-0': _index6.default,
   generic: _index5.default
 };
 Swagger.resolve = (0, _index3.makeResolve)({
-  strategies: [Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
+  strategies: [Swagger.resolveStrategies['openapi-3-2-apidom'], Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
 });
 Swagger.resolveSubtree = (0, _index4.makeResolveSubtree)({
-  strategies: [Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
+  strategies: [Swagger.resolveStrategies['openapi-3-2-apidom'], Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
 });
-Swagger.execute = _index9.execute;
+Swagger.execute = _index0.execute;
 Swagger.serializeRes = _index.serializeRes;
 Swagger.serializeHeaders = _index2.serializeHeaders;
 Swagger.clearCache = _index6.clearCache;
 Swagger.makeApisTagOperation = _interfaces.makeApisTagOperation;
-Swagger.buildRequest = _index9.buildRequest;
+Swagger.buildRequest = _index0.buildRequest;
 Swagger.helpers = {
-  opId: _index0.opId
+  opId: _index1.opId
 };
-Swagger.getBaseUrl = _index9.baseUrl;
+Swagger.getBaseUrl = _index0.baseUrl;
 Swagger.apidom = {
   resolve: {
     resolvers: {
-      HTTPResolverSwaggerClient: _index1.default
+      HTTPResolverSwaggerClient: _index10.default
     }
   },
   parse: {
     parsers: {
-      JsonParser: _index10.default,
-      YamlParser: _index11.default,
-      OpenApiJson3_1Parser: _index12.default,
-      OpenApiYaml3_1Parser: _index13.default
+      JsonParser: _index11.default,
+      YamlParser: _index12.default,
+      OpenApiJson3_1Parser: _index13.default,
+      OpenApiYaml3_1Parser: _index14.default,
+      OpenApiJson3_2Parser: _index15.default,
+      OpenApiYaml3_2Parser: _index16.default
     }
   },
   dereference: {
     strategies: {
-      OpenApi3_1SwaggerClientDereferenceStrategy: _index14.default
+      OpenApi3_1SwaggerClientDereferenceStrategy: _index17.default,
+      OpenApi3_2SwaggerClientDereferenceStrategy: _index18.default
     }
   }
 };
@@ -132,7 +140,7 @@ Swagger.prototype.applyDefaults = function applyDefaults() {
     spec
   } = this;
   const specUrl = this.url;
-  if ((0, _openapiPredicates.isOpenAPI2)(spec) && (0, _index0.isHttpUrl)(specUrl)) {
+  if ((0, _openapiPredicates.isOpenAPI2)(spec) && (0, _index1.isHttpUrl)(specUrl)) {
     const parsed = new URL(specUrl);
     if (!spec.host) {
       spec.host = parsed.host;

package/lib/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/errors/SchemaRefError.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomError = require("@swagger-api/apidom-error");
+class SchemaRefError extends _apidomError.ApiDOMStructuredError {}
+var _default = exports.default = SchemaRefError;