oas 31.0.0 → 31.1.2

package/README.md

@@ -324,9 +324,6 @@ console.log(OpenAPIReducer.init(petstore).byOperation('/pet', 'post').reduce());
 console.log(OpenAPIReducer.init(petstore).byPath('/pet').reduce());
 ```
 
-> [!NOTE]
-> Note that this does not yet support OpenAPI 3.1+ definitions that contain webhooks.
-
 ## FAQ
 
 #### Can I create an OpenAPI definition with this?

package/dist/reducer/index.cjs

@@ -8,7 +8,10 @@ var _chunkO3GIPZLCcjs = require('../chunk-O3GIPZLC.cjs');
 
 var _chunkB5WP4BJMcjs = require('../chunk-B5WP4BJM.cjs');
 require('../chunk-AYA3UT4L.cjs');
-require('../chunk-VQBEI5WI.cjs');
+
+
+
+var _chunkVQBEI5WIcjs = require('../chunk-VQBEI5WI.cjs');
 
 // src/reducer/index.ts
 var _jsonpointer = require('jsonpointer'); var _jsonpointer2 = _interopRequireDefault(_jsonpointer);
@@ -31,21 +34,35 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
    * invalid OpenAPI definition.
    */
   __init3() {this.retainPathMethods = /* @__PURE__ */ new Set()}
+  /**
+   * A collection of OpenAPI webhook names and methods that are cross-referenced from any other
+   * schemas. This collection, like `retainPathMethods`, is used in order to ensure that those
+   * schemas are retained with our resulting API definition. Not retaining them would result in an
+   * invalid OpenAPI definition.
+   */
+  __init4() {this.retainWebhookMethods = /* @__PURE__ */ new Set()}
   /**
    * An array of OpenAPI tags to reduce down to.
    */
-  __init4() {this.tagsToReduceBy = []}
+  __init5() {this.tagsToReduceBy = []}
   /**
    * A collection of OpenAPI paths and operations to reduce down to.
    */
-  __init5() {this.pathsToReduceBy = {}}
-  constructor(definition) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+  __init6() {this.pathsToReduceBy = {}}
+  /**
+   * A collection of OpenAPI webhooks to reduce down to.
+   */
+  __init7() {this.webhooksToReduceBy = {}}
+  __init8() {this.hasTagsToReduceBy = false}
+  __init9() {this.hasPathsToReduceBy = false}
+  __init10() {this.hasWebhooksToReduceBy = false}
+  constructor(definition) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);
     this.definition = structuredClone(definition);
   }
   /**
    * Initialize a new instance of the `OpenAPIReducer`. The reducer allows you to reduce an OpenAPI
    * definition down to only the information necessary to fulfill a specific set of tags, paths,
-   * and operations.
+   * operations, and webhooks.
    *
    * OpenAPI reduction can be helpful not only to isolate and troubleshoot issues with large API
    * definitions, but also to compress a large API definition down to a manageable size containing
@@ -53,8 +70,6 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
    *
    * All OpenAPI definitions reduced will still be fully functional and valid OpenAPI definitions.
    *
-   * Note that this does not yet support OpenAPI 3.1+ definitions that contain webhooks.
-   *
    * @param definition An OpenAPI definition to reduce.
    */
   static init(definition) {
@@ -102,6 +117,20 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
     }
     return this;
   }
+  byWebhook(webhookName, method) {
+    const nameLC = webhookName.toLowerCase();
+    if (!method) {
+      this.webhooksToReduceBy[nameLC] = "*";
+      return this;
+    }
+    const methodLC = method.toLowerCase();
+    if (this.webhooksToReduceBy[nameLC] && Array.isArray(this.webhooksToReduceBy[nameLC])) {
+      this.webhooksToReduceBy[nameLC].push(methodLC);
+    } else {
+      this.webhooksToReduceBy[nameLC] = [methodLC];
+    }
+    return this;
+  }
   /**
    * Reduce the current OpenAPI definition down to the configured filters.
    *
@@ -110,13 +139,9 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
     if (!this.definition.openapi) {
       throw new Error("Sorry, only OpenAPI definitions are supported.");
     }
-    if (!this.definition.openapi.startsWith("3.0")) {
-      if ("webhooks" in this.definition) {
-        return this.definition;
-      }
-    }
-    const hasPathsToReduceBy = Boolean(Object.keys(this.pathsToReduceBy).length);
-    const hasTagsToReduceBy = Boolean(this.tagsToReduceBy.length);
+    this.hasPathsToReduceBy = Boolean(Object.keys(this.pathsToReduceBy).length);
+    this.hasWebhooksToReduceBy = Boolean(Object.keys(this.webhooksToReduceBy).length);
+    this.hasTagsToReduceBy = Boolean(this.tagsToReduceBy.length);
     if ("security" in this.definition) {
       Object.values(this.definition.security || {}).forEach((sec) => {
         Object.keys(sec).forEach((scheme) => {
@@ -124,134 +149,44 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
         });
       });
     }
-    if ("paths" in this.definition) {
-      Object.keys(this.definition.paths || {}).forEach((path) => {
-        const pathLC = path.toLowerCase();
-        if (hasPathsToReduceBy) {
-          if (!(pathLC in this.pathsToReduceBy)) {
-             _optionalChainDelete([this, 'access', _ => _.definition, 'access', _2 => _2.paths, 'optionalAccess', _3 => delete _3[path]]);
-            return;
-          }
-        }
-        Object.keys(_optionalChain([this, 'access', _4 => _4.definition, 'access', _5 => _5.paths, 'optionalAccess', _6 => _6[path]]) || {}).forEach((method) => {
-          if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(method.toLowerCase())) {
-            return;
-          }
-          if (hasPathsToReduceBy) {
-            if (this.pathsToReduceBy[pathLC] !== "*" && Array.isArray(this.pathsToReduceBy[pathLC]) && !this.pathsToReduceBy[pathLC].includes(method.toLowerCase())) {
-              return;
-            }
-          }
-          const operation = _optionalChain([this, 'access', _7 => _7.definition, 'access', _8 => _8.paths, 'optionalAccess', _9 => _9[path], 'optionalAccess', _10 => _10[method]]);
-          if (!operation) {
-            throw new Error(`Operation \`${method} ${path}\` not found`);
-          }
-          if (hasTagsToReduceBy) {
-            if (!(operation.tags || []).filter((tag) => this.tagsToReduceBy.includes(tag.toLowerCase())).length) {
-              return;
-            }
-          }
-          (operation.tags || []).forEach((tag) => {
-            this.usedTags.add(tag);
-          });
-          this.queryForRefPointers(operation).forEach(({ value: ref }) => {
-            const refStr = this.toRefString(ref);
-            if (!refStr) {
-              return;
-            }
-            this.$refs.add(refStr);
-            const pathRef = this.parsePathRef(refStr);
-            if (pathRef) {
-              this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
-            }
-            this.accumulateUsedRefs(this.definition, this.$refs, refStr);
-          });
-          Object.values(operation.security || {}).forEach((sec) => {
-            Object.keys(sec).forEach((scheme) => {
-              this.$refs.add(`#/components/securitySchemes/${scheme}`);
-            });
-          });
-        });
-      });
-      this.$refs.forEach(($ref) => {
-        this.accumulateUsedRefs(this.definition, this.$refs, $ref);
-      });
-      this.$refs.forEach((ref) => {
-        const usedPathRef = this.parsePathRef(ref);
-        if (usedPathRef) {
-          this.retainPathMethods.add(`${usedPathRef.path.toLowerCase()}|${usedPathRef.method.toLowerCase()}`);
-        }
-      });
-      Object.keys(this.definition.paths || {}).forEach((path) => {
-        const pathLC = path.toLowerCase();
-        if (hasPathsToReduceBy && !(pathLC in this.pathsToReduceBy)) {
-           _optionalChainDelete([this, 'access', _11 => _11.definition, 'access', _12 => _12.paths, 'optionalAccess', _13 => delete _13[path]]);
-          return;
-        }
-        Object.keys(_optionalChain([this, 'access', _14 => _14.definition, 'access', _15 => _15.paths, 'optionalAccess', _16 => _16[path]]) || {}).forEach((method) => {
-          const methodLC = method.toLowerCase();
-          if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(methodLC)) {
-            return;
-          }
-          const retainedByRef = this.retainPathMethods.has(`${pathLC}|${methodLC}`) || Array.from(this.$refs).some((ref) => {
-            const pathRef = this.parsePathRef(ref);
-            return _optionalChain([pathRef, 'optionalAccess', _17 => _17.path, 'access', _18 => _18.toLowerCase, 'call', _19 => _19()]) === pathLC && _optionalChain([pathRef, 'optionalAccess', _20 => _20.method, 'access', _21 => _21.toLowerCase, 'call', _22 => _22()]) === methodLC;
-          });
-          if (methodLC !== "parameters") {
-            if (hasPathsToReduceBy) {
-              if (!retainedByRef && this.pathsToReduceBy[pathLC] !== "*" && Array.isArray(this.pathsToReduceBy[pathLC]) && !this.pathsToReduceBy[pathLC].includes(methodLC)) {
-                 _optionalChainDelete([this, 'access', _23 => _23.definition, 'access', _24 => _24.paths, 'optionalAccess', _25 => _25[path], 'optionalAccess', _26 => delete _26[method]]);
-                return;
-              }
-            }
-          }
-          const operation = _optionalChain([this, 'access', _27 => _27.definition, 'access', _28 => _28.paths, 'optionalAccess', _29 => _29[path], 'optionalAccess', _30 => _30[method]]);
-          if (!operation) {
-            throw new Error(`Operation \`${method} ${path}\` not found`);
-          }
-          if (hasTagsToReduceBy) {
-            if (!(operation.tags || []).filter((tag) => this.tagsToReduceBy.includes(tag.toLowerCase())).length) {
-              if (!retainedByRef) {
-                 _optionalChainDelete([this, 'access', _31 => _31.definition, 'access', _32 => _32.paths, 'optionalAccess', _33 => _33[path], 'optionalAccess', _34 => delete _34[method]]);
-              }
-              return;
-            }
-          }
-          if ("tags" in operation) {
-            _optionalChain([operation, 'access', _35 => _35.tags, 'optionalAccess', _36 => _36.forEach, 'call', _37 => _37((tag) => {
-              this.usedTags.add(tag);
-            })]);
-          }
-          if ("security" in operation) {
-            Object.values(operation.security || {}).forEach((sec) => {
-              Object.keys(sec).forEach((scheme) => {
-                this.$refs.add(`#/components/securitySchemes/${scheme}`);
-              });
-            });
-          }
-        });
-        if (!Object.keys(_optionalChain([this, 'access', _38 => _38.definition, 'access', _39 => _39.paths, 'optionalAccess', _40 => _40[path]]) || {}).length) {
-           _optionalChainDelete([this, 'access', _41 => _41.definition, 'access', _42 => _42.paths, 'optionalAccess', _43 => delete _43[path]]);
-        }
-      });
-      if (!Object.keys(this.definition.paths || {}).length) {
-        throw new Error(
-          "All paths in the API definition were removed. Did you supply the right path name to reduce by?"
-        );
+    this.walkPaths();
+    this.walkWebhooks();
+    this.$refs.forEach(($ref) => {
+      this.accumulateUsedRefs(this.definition, this.$refs, $ref);
+    });
+    this.$refs.forEach((ref) => {
+      const usedPathRef = this.parsePathRef(ref);
+      if (usedPathRef) {
+        this.retainPathMethods.add(`${usedPathRef.path.toLowerCase()}|${usedPathRef.method.toLowerCase()}`);
+      }
+      const usedWebhookRef = this.parseWebhookRef(ref);
+      if (usedWebhookRef) {
+        this.retainWebhookMethods.add(`${usedWebhookRef.name.toLowerCase()}|${usedWebhookRef.method.toLowerCase()}`);
       }
+    });
+    this.reducePaths();
+    this.reduceWebhooks();
+    const hasPaths = Boolean(this.definition.paths && Object.keys(this.definition.paths).length);
+    const hasWebhooks = Boolean(
+      "webhooks" in this.definition && this.definition.webhooks && Object.keys(this.definition.webhooks).length
+    );
+    if (!hasPaths && !hasWebhooks) {
+      throw new Error(
+        "All paths and webhooks in the API definition were removed. Did you supply the right path, operation, or webhook to reduce by?"
+      );
     }
     if ("components" in this.definition) {
       Object.keys(this.definition.components || {}).forEach((componentType) => {
-        Object.keys(_optionalChain([this, 'access', _44 => _44.definition, 'access', _45 => _45.components, 'optionalAccess', _46 => _46[componentType]]) || {}).forEach((component) => {
+        Object.keys(_optionalChain([this, 'access', _ => _.definition, 'access', _2 => _2.components, 'optionalAccess', _3 => _3[componentType]]) || {}).forEach((component) => {
           const refIsUsed = this.$refs.has(`#/components/${componentType}/${component}`) || Array.from(this.$refs).some((ref) => {
             return ref.startsWith(`#/components/${componentType}/${component}/`);
           });
           if (!refIsUsed) {
-             _optionalChainDelete([this, 'access', _47 => _47.definition, 'access', _48 => _48.components, 'optionalAccess', _49 => _49[componentType], 'optionalAccess', _50 => delete _50[component]]);
+             _optionalChainDelete([this, 'access', _4 => _4.definition, 'access', _5 => _5.components, 'optionalAccess', _6 => _6[componentType], 'optionalAccess', _7 => delete _7[component]]);
           }
         });
-        if (!Object.keys(_optionalChain([this, 'access', _51 => _51.definition, 'access', _52 => _52.components, 'optionalAccess', _53 => _53[componentType]]) || {}).length) {
-           _optionalChainDelete([this, 'access', _54 => _54.definition, 'access', _55 => _55.components, 'optionalAccess', _56 => delete _56[componentType]]);
+        if (!Object.keys(_optionalChain([this, 'access', _8 => _8.definition, 'access', _9 => _9.components, 'optionalAccess', _10 => _10[componentType]]) || {}).length) {
+           _optionalChainDelete([this, 'access', _11 => _11.definition, 'access', _12 => _12.components, 'optionalAccess', _13 => delete _13[componentType]]);
         }
       });
       if (!Object.keys(this.definition.components || {}).length) {
@@ -262,7 +197,7 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
       this.definition.tags = (_nullishCoalesce(this.definition.tags, () => ( []))).filter((tag) => {
         return Boolean(tag) && this.usedTags.has(tag.name);
       });
-      if (!_optionalChain([this, 'access', _57 => _57.definition, 'access', _58 => _58.tags, 'optionalAccess', _59 => _59.length])) {
+      if (!_optionalChain([this, 'access', _14 => _14.definition, 'access', _15 => _15.tags, 'optionalAccess', _16 => _16.length])) {
         delete this.definition.tags;
       }
     }
@@ -283,6 +218,10 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
     if (pathRef) {
       this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
     }
+    const webhookRef = this.parseWebhookRef($ref);
+    if (webhookRef) {
+      this.retainWebhookMethods.add(`${webhookRef.name.toLowerCase()}|${webhookRef.method.toLowerCase()}`);
+    }
     let $refSchema;
     if (typeof $ref === "string") $refSchema = _jsonpointer2.default.get(schema, $ref.substring(1));
     if ($refSchema === void 0) {
@@ -324,8 +263,8 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
     return null;
   }
   /**
-   * If the given `$ref` points into a path (e.g. `#/paths/~1anything/post/...`), return the path and
-   * method so the reducer can ultimately retain cross-operation references.
+   * If the given `$ref` points into a path (e.g. `#/paths/~1anything/post/...`), return the path
+   * and method so the reducer can ultimately retain cross-operation references.
    *
    */
   parsePathRef($ref) {
@@ -342,6 +281,283 @@ var OpenAPIReducer = (_class = class _OpenAPIReducer {
     }
     return null;
   }
+  /**
+   * If the given `$ref` points into webhooks (e.g. `#/webhooks/newBooking/post/...`), return the
+   * webhook name and method so the reducer can retain cross-referenced webhook operations.
+   *
+   */
+  parseWebhookRef($ref) {
+    if (typeof $ref !== "string" || !$ref.startsWith("#/webhooks/")) {
+      return null;
+    }
+    const match = $ref.match(/^#\/webhooks\/([^/]+)\/([^/]+)(?:\/|$)/);
+    if (match) {
+      const webhookName = match[1];
+      const method = match[2];
+      if (webhookName && method) {
+        return { name: _chunkB5WP4BJMcjs.decodePointer.call(void 0, webhookName), method };
+      }
+    }
+    return null;
+  }
+  /**
+   * Walk through the `paths` in our OpenAPI definition and reduce down any that we know we do not
+   * want to keep and accumulate any `$ref` pointers that we find that may be cross-referenced in
+   * paths, webhooks, operations, and schemas that we _do_ want to keep.
+   *
+   */
+  walkPaths() {
+    if (!("paths" in this.definition) || !this.definition.paths) {
+      return;
+    }
+    Object.keys(this.definition.paths).forEach((path) => {
+      const pathLC = path.toLowerCase();
+      if (this.hasWebhooksToReduceBy && !this.hasPathsToReduceBy) {
+         _optionalChainDelete([this, 'access', _17 => _17.definition, 'access', _18 => _18.paths, 'optionalAccess', _19 => delete _19[path]]);
+        return;
+      }
+      if (this.hasPathsToReduceBy) {
+        if (!(pathLC in this.pathsToReduceBy)) {
+           _optionalChainDelete([this, 'access', _20 => _20.definition, 'access', _21 => _21.paths, 'optionalAccess', _22 => delete _22[path]]);
+          return;
+        }
+      }
+      Object.keys(_optionalChain([this, 'access', _23 => _23.definition, 'access', _24 => _24.paths, 'optionalAccess', _25 => _25[path]]) || {}).forEach((method) => {
+        if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(method.toLowerCase())) {
+          return;
+        }
+        if (this.hasPathsToReduceBy) {
+          if (this.pathsToReduceBy[pathLC] !== "*" && Array.isArray(this.pathsToReduceBy[pathLC]) && !this.pathsToReduceBy[pathLC].includes(method.toLowerCase())) {
+            return;
+          }
+        }
+        const operation = _optionalChain([this, 'access', _26 => _26.definition, 'access', _27 => _27.paths, 'optionalAccess', _28 => _28[path], 'optionalAccess', _29 => _29[method]]);
+        if (!operation) {
+          throw new Error(`Operation \`${method} ${path}\` not found`);
+        }
+        if (this.hasTagsToReduceBy) {
+          if (!(operation.tags || []).filter((tag) => this.tagsToReduceBy.includes(tag.toLowerCase())).length) {
+            return;
+          }
+        }
+        (operation.tags || []).forEach((tag) => {
+          this.usedTags.add(tag);
+        });
+        this.queryForRefPointers(operation).forEach(({ value: ref }) => {
+          const refStr = this.toRefString(ref);
+          if (!refStr) {
+            return;
+          }
+          this.$refs.add(refStr);
+          const pathRef = this.parsePathRef(refStr);
+          if (pathRef) {
+            this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
+          }
+          this.accumulateUsedRefs(this.definition, this.$refs, refStr);
+        });
+        Object.values(operation.security || {}).forEach((sec) => {
+          Object.keys(sec).forEach((scheme) => {
+            this.$refs.add(`#/components/securitySchemes/${scheme}`);
+          });
+        });
+      });
+    });
+  }
+  /**
+   * Walk through the `webhooks` in our OpenAPI definition and reduce down any that we know we do
+   * not want to keep and accumulate any `$ref` pointers that we find that may be cross-referenced
+   * in paths, operations, and schemas that we _do_ want to keep.
+   *
+   */
+  walkWebhooks() {
+    if (!_chunkVQBEI5WIcjs.isOpenAPI31.call(void 0, this.definition)) {
+      return;
+    } else if (!("webhooks" in this.definition) || !this.definition.webhooks) {
+      return;
+    }
+    const definition = this.definition;
+    Object.keys(definition.webhooks || {}).forEach((webhookName) => {
+      const nameLC = webhookName.toLowerCase();
+      if (this.hasWebhooksToReduceBy && !(nameLC in this.webhooksToReduceBy)) {
+        return;
+      }
+      const webhook = _optionalChain([definition, 'access', _30 => _30.webhooks, 'optionalAccess', _31 => _31[webhookName]]);
+      if (!webhook || typeof webhook !== "object") {
+        return;
+      }
+      Object.keys(webhook).forEach((method) => {
+        if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(method.toLowerCase())) {
+          return;
+        }
+        if (this.hasWebhooksToReduceBy) {
+          const methodFilter = this.webhooksToReduceBy[nameLC];
+          if (methodFilter !== "*" && Array.isArray(methodFilter) && !methodFilter.includes(method.toLowerCase())) {
+            return;
+          }
+        }
+        if (_chunkVQBEI5WIcjs.isRef.call(void 0, webhook)) {
+          return;
+        }
+        const operation = webhook[method];
+        if (!operation) {
+          return;
+        }
+        if (this.hasTagsToReduceBy) {
+          if (!(operation.tags || []).filter((tag) => this.tagsToReduceBy.includes(tag.toLowerCase())).length) {
+            return;
+          }
+        }
+        (operation.tags || []).forEach((tag) => {
+          this.usedTags.add(tag);
+        });
+        this.queryForRefPointers(operation).forEach(({ value: ref }) => {
+          const refStr = this.toRefString(ref);
+          if (!refStr) {
+            return;
+          }
+          this.$refs.add(refStr);
+          const pathRef = this.parsePathRef(refStr);
+          if (pathRef) {
+            this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
+          }
+          const webhookRef = this.parseWebhookRef(refStr);
+          if (webhookRef) {
+            this.retainWebhookMethods.add(`${webhookRef.name.toLowerCase()}|${webhookRef.method.toLowerCase()}`);
+          }
+          this.accumulateUsedRefs(definition, this.$refs, refStr);
+        });
+        Object.values(operation.security || {}).forEach((sec) => {
+          Object.keys(sec).forEach((scheme) => {
+            this.$refs.add(`#/components/securitySchemes/${scheme}`);
+          });
+        });
+      });
+    });
+  }
+  /**
+   * Prune back our `paths` object in the OpenAPI definition to only include paths that we want to
+   * preserve.
+   *
+   */
+  reducePaths() {
+    if (!("paths" in this.definition) || !this.definition.paths) {
+      return;
+    }
+    Object.keys(this.definition.paths).forEach((path) => {
+      const pathLC = path.toLowerCase();
+      if (this.hasPathsToReduceBy && !(pathLC in this.pathsToReduceBy)) {
+         _optionalChainDelete([this, 'access', _32 => _32.definition, 'access', _33 => _33.paths, 'optionalAccess', _34 => delete _34[path]]);
+        return;
+      }
+      Object.keys(_optionalChain([this, 'access', _35 => _35.definition, 'access', _36 => _36.paths, 'optionalAccess', _37 => _37[path]]) || {}).forEach((method) => {
+        const methodLC = method.toLowerCase();
+        if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(methodLC)) {
+          return;
+        }
+        const retainedByRef = this.retainPathMethods.has(`${pathLC}|${methodLC}`) || Array.from(this.$refs).some((ref) => {
+          const pathRef = this.parsePathRef(ref);
+          return _optionalChain([pathRef, 'optionalAccess', _38 => _38.path, 'access', _39 => _39.toLowerCase, 'call', _40 => _40()]) === pathLC && _optionalChain([pathRef, 'optionalAccess', _41 => _41.method, 'access', _42 => _42.toLowerCase, 'call', _43 => _43()]) === methodLC;
+        });
+        if (methodLC !== "parameters") {
+          if (this.hasPathsToReduceBy) {
+            if (!retainedByRef && this.pathsToReduceBy[pathLC] !== "*" && Array.isArray(this.pathsToReduceBy[pathLC]) && !this.pathsToReduceBy[pathLC].includes(methodLC)) {
+               _optionalChainDelete([this, 'access', _44 => _44.definition, 'access', _45 => _45.paths, 'optionalAccess', _46 => _46[path], 'optionalAccess', _47 => delete _47[method]]);
+              return;
+            }
+          }
+        }
+        const operation = _optionalChain([this, 'access', _48 => _48.definition, 'access', _49 => _49.paths, 'optionalAccess', _50 => _50[path], 'optionalAccess', _51 => _51[method]]);
+        if (!operation) {
+          throw new Error(`Operation \`${method} ${path}\` not found`);
+        }
+        if (this.hasTagsToReduceBy) {
+          if (!(operation.tags || []).filter((tag) => this.tagsToReduceBy.includes(tag.toLowerCase())).length) {
+            if (!retainedByRef) {
+               _optionalChainDelete([this, 'access', _52 => _52.definition, 'access', _53 => _53.paths, 'optionalAccess', _54 => _54[path], 'optionalAccess', _55 => delete _55[method]]);
+            }
+            return;
+          }
+        }
+        if ("tags" in operation) {
+          _optionalChain([operation, 'access', _56 => _56.tags, 'optionalAccess', _57 => _57.forEach, 'call', _58 => _58((tag) => {
+            this.usedTags.add(tag);
+          })]);
+        }
+        if ("security" in operation) {
+          Object.values(operation.security || {}).forEach((sec) => {
+            Object.keys(sec).forEach((scheme) => {
+              this.$refs.add(`#/components/securitySchemes/${scheme}`);
+            });
+          });
+        }
+      });
+      if (!Object.keys(_optionalChain([this, 'access', _59 => _59.definition, 'access', _60 => _60.paths, 'optionalAccess', _61 => _61[path]]) || {}).length) {
+         _optionalChainDelete([this, 'access', _62 => _62.definition, 'access', _63 => _63.paths, 'optionalAccess', _64 => delete _64[path]]);
+      }
+    });
+    if (!Object.keys(this.definition.paths || {}).length) {
+      if (!(this.definition.webhooks && Object.keys(this.definition.webhooks).length)) {
+        throw new Error(
+          "All paths in the API definition were removed. Did you supply the right path name to reduce by?"
+        );
+      }
+      delete this.definition.paths;
+    }
+  }
+  /**
+   * Prune back our `webhooks` object in the OpenAPI definition to only include webhooks that we
+   * want to preserve.
+   *
+   */
+  reduceWebhooks() {
+    if (!_chunkVQBEI5WIcjs.isOpenAPI31.call(void 0, this.definition)) {
+      return;
+    } else if (!("webhooks" in this.definition) || !this.definition.webhooks) {
+      return;
+    }
+    const definition = this.definition;
+    Object.keys(definition.webhooks || {}).forEach((webhookName) => {
+      const nameLC = webhookName.toLowerCase();
+      if (this.hasWebhooksToReduceBy && !(nameLC in this.webhooksToReduceBy)) {
+        const retainedByRef = Array.from(this.retainWebhookMethods).some(
+          (key) => key.startsWith(`${nameLC}|`) || key === `${nameLC}|`
+        );
+        if (!retainedByRef) {
+           _optionalChainDelete([definition, 'access', _65 => _65.webhooks, 'optionalAccess', _66 => delete _66[webhookName]]);
+          return;
+        }
+      }
+      const webhook = _optionalChain([definition, 'access', _67 => _67.webhooks, 'optionalAccess', _68 => _68[webhookName]]);
+      if (!webhook || typeof webhook !== "object") {
+        return;
+      }
+      if (_chunkVQBEI5WIcjs.isRef.call(void 0, webhook)) {
+        return;
+      }
+      Object.keys(webhook).forEach((method) => {
+        const methodLC = method.toLowerCase();
+        if (method === "parameters" || !_chunkO3GIPZLCcjs.supportedMethods.includes(methodLC)) {
+          return;
+        }
+        const retainedByRef = this.retainWebhookMethods.has(`${nameLC}|${methodLC}`);
+        if (this.hasWebhooksToReduceBy && !retainedByRef) {
+          const methodFilter = this.webhooksToReduceBy[nameLC];
+          if (methodFilter !== "*" && Array.isArray(methodFilter) && !methodFilter.includes(methodLC)) {
+            if (_chunkVQBEI5WIcjs.isRef.call(void 0, _optionalChain([definition, 'access', _69 => _69.webhooks, 'optionalAccess', _70 => _70[webhookName]]))) {
+              return;
+            }
+             _optionalChainDelete([definition, 'access', _71 => _71.webhooks, 'optionalAccess', _72 => _72[webhookName], 'optionalAccess', _73 => delete _73[method]]);
+          }
+        }
+      });
+      if (!Object.keys(_optionalChain([definition, 'access', _74 => _74.webhooks, 'optionalAccess', _75 => _75[webhookName]]) || {}).length) {
+         _optionalChainDelete([definition, 'access', _76 => _76.webhooks, 'optionalAccess', _77 => delete _77[webhookName]]);
+      }
+    });
+    if (definition.webhooks && !Object.keys(definition.webhooks).length) {
+      delete definition.webhooks;
+    }
+  }
 }, _class);