zotero-plugin 2.0.21 → 2.0.23

package/bin/branches.js

@@ -1,27 +1,3585 @@
 #!/usr/bin/env node
-"use strict";
-/* eslint-disable no-console, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-process.on('unhandledRejection', up => { throw up; });
-require("dotenv/config");
-const path = tslib_1.__importStar(require("path"));
-const rest_1 = require("@octokit/rest");
-const octokit = new rest_1.Octokit({ auth: `token ${process.env.GITHUB_TOKEN}` });
-const root_1 = tslib_1.__importDefault(require("../root"));
-const pkg = require(path.join(root_1.default, 'package.json'));
-const [, owner, repo] = pkg.repository.url.match(/:\/\/github.com\/([^/]+)\/([^.]+)\.git$/);
-async function main() {
-    const branches = await octokit.repos.listBranches({ owner, repo });
-    for (const branch of branches.data) {
-        if (/^[0-9]+$/.exec(branch.name)) {
-            const issue = await octokit.issues.get({ owner, repo, issue_number: parseInt(branch.name) });
-            if (issue.data.state !== 'open')
-                console.log(branch.name, issue.data.state); // eslint-disable-line no-console
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/dotenv/package.json
+  var require_package = __commonJS({
+    "node_modules/dotenv/package.json"(exports, module) {
+      module.exports = {
+        name: "dotenv",
+        version: "16.4.5",
+        description: "Loads environment variables from .env file",
+        main: "lib/main.js",
+        types: "lib/main.d.ts",
+        exports: {
+          ".": {
+            types: "./lib/main.d.ts",
+            require: "./lib/main.js",
+            default: "./lib/main.js"
+          },
+          "./config": "./config.js",
+          "./config.js": "./config.js",
+          "./lib/env-options": "./lib/env-options.js",
+          "./lib/env-options.js": "./lib/env-options.js",
+          "./lib/cli-options": "./lib/cli-options.js",
+          "./lib/cli-options.js": "./lib/cli-options.js",
+          "./package.json": "./package.json"
+        },
+        scripts: {
+          "dts-check": "tsc --project tests/types/tsconfig.json",
+          lint: "standard",
+          "lint-readme": "standard-markdown",
+          pretest: "npm run lint && npm run dts-check",
+          test: "tap tests/*.js --100 -Rspec",
+          "test:coverage": "tap --coverage-report=lcov",
+          prerelease: "npm test",
+          release: "standard-version"
+        },
+        repository: {
+          type: "git",
+          url: "git://github.com/motdotla/dotenv.git"
+        },
+        funding: "https://dotenvx.com",
+        keywords: [
+          "dotenv",
+          "env",
+          ".env",
+          "environment",
+          "variables",
+          "config",
+          "settings"
+        ],
+        readmeFilename: "README.md",
+        license: "BSD-2-Clause",
+        devDependencies: {
+          "@definitelytyped/dtslint": "^0.0.133",
+          "@types/node": "^18.11.3",
+          decache: "^4.6.1",
+          sinon: "^14.0.1",
+          standard: "^17.0.0",
+          "standard-markdown": "^7.1.0",
+          "standard-version": "^9.5.0",
+          tap: "^16.3.0",
+          tar: "^6.1.11",
+          typescript: "^4.8.4"
+        },
+        engines: {
+          node: ">=12"
+        },
+        browser: {
+          fs: false
+        }
+      };
+    }
+  });
+
+  // node_modules/dotenv/lib/main.js
+  var require_main = __commonJS({
+    "node_modules/dotenv/lib/main.js"(exports, module) {
+      var fs = __require("fs");
+      var path2 = __require("path");
+      var os = __require("os");
+      var crypto = __require("crypto");
+      var packageJson = require_package();
+      var version = packageJson.version;
+      var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+      function parse2(src) {
+        const obj = {};
+        let lines = src.toString();
+        lines = lines.replace(/\r\n?/mg, "\n");
+        let match;
+        while ((match = LINE.exec(lines)) != null) {
+          const key = match[1];
+          let value = match[2] || "";
+          value = value.trim();
+          const maybeQuote = value[0];
+          value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+          if (maybeQuote === '"') {
+            value = value.replace(/\\n/g, "\n");
+            value = value.replace(/\\r/g, "\r");
+          }
+          obj[key] = value;
+        }
+        return obj;
+      }
+      function _parseVault(options) {
+        const vaultPath = _vaultPath(options);
+        const result = DotenvModule.configDotenv({ path: vaultPath });
+        if (!result.parsed) {
+          const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+          err.code = "MISSING_DATA";
+          throw err;
+        }
+        const keys = _dotenvKey(options).split(",");
+        const length = keys.length;
+        let decrypted;
+        for (let i = 0; i < length; i++) {
+          try {
+            const key = keys[i].trim();
+            const attrs = _instructions(result, key);
+            decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+            break;
+          } catch (error) {
+            if (i + 1 >= length) {
+              throw error;
+            }
+          }
+        }
+        return DotenvModule.parse(decrypted);
+      }
+      function _log(message) {
+        console.log(`[dotenv@${version}][INFO] ${message}`);
+      }
+      function _warn(message) {
+        console.log(`[dotenv@${version}][WARN] ${message}`);
+      }
+      function _debug(message) {
+        console.log(`[dotenv@${version}][DEBUG] ${message}`);
+      }
+      function _dotenvKey(options) {
+        if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+          return options.DOTENV_KEY;
+        }
+        if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+          return process.env.DOTENV_KEY;
+        }
+        return "";
+      }
+      function _instructions(result, dotenvKey) {
+        let uri;
+        try {
+          uri = new URL(dotenvKey);
+        } catch (error) {
+          if (error.code === "ERR_INVALID_URL") {
+            const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+            err.code = "INVALID_DOTENV_KEY";
+            throw err;
+          }
+          throw error;
+        }
+        const key = uri.password;
+        if (!key) {
+          const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        const environment = uri.searchParams.get("environment");
+        if (!environment) {
+          const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+        const ciphertext = result.parsed[environmentKey];
+        if (!ciphertext) {
+          const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+          err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+          throw err;
+        }
+        return { ciphertext, key };
+      }
+      function _vaultPath(options) {
+        let possibleVaultPath = null;
+        if (options && options.path && options.path.length > 0) {
+          if (Array.isArray(options.path)) {
+            for (const filepath of options.path) {
+              if (fs.existsSync(filepath)) {
+                possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+              }
+            }
+          } else {
+            possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+          }
+        } else {
+          possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+        }
+        if (fs.existsSync(possibleVaultPath)) {
+          return possibleVaultPath;
+        }
+        return null;
+      }
+      function _resolveHome(envPath) {
+        return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+      }
+      function _configVault(options) {
+        _log("Loading env from encrypted .env.vault");
+        const parsed = DotenvModule._parseVault(options);
+        let processEnv = process.env;
+        if (options && options.processEnv != null) {
+          processEnv = options.processEnv;
+        }
+        DotenvModule.populate(processEnv, parsed, options);
+        return { parsed };
+      }
+      function configDotenv(options) {
+        const dotenvPath = path2.resolve(process.cwd(), ".env");
+        let encoding = "utf8";
+        const debug = Boolean(options && options.debug);
+        if (options && options.encoding) {
+          encoding = options.encoding;
+        } else {
+          if (debug) {
+            _debug("No encoding is specified. UTF-8 is used by default");
+          }
+        }
+        let optionPaths = [dotenvPath];
+        if (options && options.path) {
+          if (!Array.isArray(options.path)) {
+            optionPaths = [_resolveHome(options.path)];
+          } else {
+            optionPaths = [];
+            for (const filepath of options.path) {
+              optionPaths.push(_resolveHome(filepath));
+            }
+          }
+        }
+        let lastError;
+        const parsedAll = {};
+        for (const path3 of optionPaths) {
+          try {
+            const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
+            DotenvModule.populate(parsedAll, parsed, options);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${path3} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        let processEnv = process.env;
+        if (options && options.processEnv != null) {
+          processEnv = options.processEnv;
+        }
+        DotenvModule.populate(processEnv, parsedAll, options);
+        if (lastError) {
+          return { parsed: parsedAll, error: lastError };
+        } else {
+          return { parsed: parsedAll };
+        }
+      }
+      function config(options) {
+        if (_dotenvKey(options).length === 0) {
+          return DotenvModule.configDotenv(options);
+        }
+        const vaultPath = _vaultPath(options);
+        if (!vaultPath) {
+          _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+          return DotenvModule.configDotenv(options);
+        }
+        return DotenvModule._configVault(options);
+      }
+      function decrypt(encrypted, keyStr) {
+        const key = Buffer.from(keyStr.slice(-64), "hex");
+        let ciphertext = Buffer.from(encrypted, "base64");
+        const nonce = ciphertext.subarray(0, 12);
+        const authTag = ciphertext.subarray(-16);
+        ciphertext = ciphertext.subarray(12, -16);
+        try {
+          const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+          aesgcm.setAuthTag(authTag);
+          return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+        } catch (error) {
+          const isRange = error instanceof RangeError;
+          const invalidKeyLength = error.message === "Invalid key length";
+          const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+          if (isRange || invalidKeyLength) {
+            const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+            err.code = "INVALID_DOTENV_KEY";
+            throw err;
+          } else if (decryptionFailed) {
+            const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+            err.code = "DECRYPTION_FAILED";
+            throw err;
+          } else {
+            throw error;
+          }
+        }
+      }
+      function populate(processEnv, parsed, options = {}) {
+        const debug = Boolean(options && options.debug);
+        const override = Boolean(options && options.override);
+        if (typeof parsed !== "object") {
+          const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+          err.code = "OBJECT_REQUIRED";
+          throw err;
+        }
+        for (const key of Object.keys(parsed)) {
+          if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+            if (override === true) {
+              processEnv[key] = parsed[key];
+            }
+            if (debug) {
+              if (override === true) {
+                _debug(`"${key}" is already defined and WAS overwritten`);
+              } else {
+                _debug(`"${key}" is already defined and was NOT overwritten`);
+              }
+            }
+          } else {
+            processEnv[key] = parsed[key];
+          }
+        }
+      }
+      var DotenvModule = {
+        configDotenv,
+        _configVault,
+        _parseVault,
+        config,
+        decrypt,
+        parse: parse2,
+        populate
+      };
+      module.exports.configDotenv = DotenvModule.configDotenv;
+      module.exports._configVault = DotenvModule._configVault;
+      module.exports._parseVault = DotenvModule._parseVault;
+      module.exports.config = DotenvModule.config;
+      module.exports.decrypt = DotenvModule.decrypt;
+      module.exports.parse = DotenvModule.parse;
+      module.exports.populate = DotenvModule.populate;
+      module.exports = DotenvModule;
+    }
+  });
+
+  // node_modules/dotenv/lib/env-options.js
+  var require_env_options = __commonJS({
+    "node_modules/dotenv/lib/env-options.js"(exports, module) {
+      var options = {};
+      if (process.env.DOTENV_CONFIG_ENCODING != null) {
+        options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+      }
+      if (process.env.DOTENV_CONFIG_PATH != null) {
+        options.path = process.env.DOTENV_CONFIG_PATH;
+      }
+      if (process.env.DOTENV_CONFIG_DEBUG != null) {
+        options.debug = process.env.DOTENV_CONFIG_DEBUG;
+      }
+      if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+        options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+      }
+      if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+        options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+      }
+      module.exports = options;
+    }
+  });
+
+  // node_modules/dotenv/lib/cli-options.js
+  var require_cli_options = __commonJS({
+    "node_modules/dotenv/lib/cli-options.js"(exports, module) {
+      var re = /^dotenv_config_(encoding|path|debug|override|DOTENV_KEY)=(.+)$/;
+      module.exports = function optionMatcher(args) {
+        return args.reduce(function(acc, cur) {
+          const matches = cur.match(re);
+          if (matches) {
+            acc[matches[1]] = matches[2];
+          }
+          return acc;
+        }, {});
+      };
+    }
+  });
+
+  // node_modules/dotenv/config.js
+  (function() {
+    require_main().config(
+      Object.assign(
+        {},
+        require_env_options(),
+        require_cli_options()(process.argv)
+      )
+    );
+  })();
+
+  // bin/branches.ts
+  var path = __toESM(__require("path"));
+
+  // node_modules/@octokit/rest/node_modules/universal-user-agent/index.js
+  function getUserAgent() {
+    if (typeof navigator === "object" && "userAgent" in navigator) {
+      return navigator.userAgent;
+    }
+    if (typeof process === "object" && process.version !== void 0) {
+      return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
+    }
+    return "<environment undetectable>";
+  }
+
+  // node_modules/@octokit/rest/node_modules/before-after-hook/lib/register.js
+  function register(state, name, method, options) {
+    if (typeof method !== "function") {
+      throw new Error("method for before hook must be a function");
+    }
+    if (!options) {
+      options = {};
+    }
+    if (Array.isArray(name)) {
+      return name.reverse().reduce((callback, name2) => {
+        return register.bind(null, state, name2, callback, options);
+      }, method)();
+    }
+    return Promise.resolve().then(() => {
+      if (!state.registry[name]) {
+        return method(options);
+      }
+      return state.registry[name].reduce((method2, registered) => {
+        return registered.hook.bind(null, method2, options);
+      }, method)();
+    });
+  }
+
+  // node_modules/@octokit/rest/node_modules/before-after-hook/lib/add.js
+  function addHook(state, kind, name, hook2) {
+    const orig = hook2;
+    if (!state.registry[name]) {
+      state.registry[name] = [];
+    }
+    if (kind === "before") {
+      hook2 = (method, options) => {
+        return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options));
+      };
+    }
+    if (kind === "after") {
+      hook2 = (method, options) => {
+        let result;
+        return Promise.resolve().then(method.bind(null, options)).then((result_) => {
+          result = result_;
+          return orig(result, options);
+        }).then(() => {
+          return result;
+        });
+      };
+    }
+    if (kind === "error") {
+      hook2 = (method, options) => {
+        return Promise.resolve().then(method.bind(null, options)).catch((error) => {
+          return orig(error, options);
+        });
+      };
+    }
+    state.registry[name].push({
+      hook: hook2,
+      orig
+    });
+  }
+
+  // node_modules/@octokit/rest/node_modules/before-after-hook/lib/remove.js
+  function removeHook(state, name, method) {
+    if (!state.registry[name]) {
+      return;
+    }
+    const index = state.registry[name].map((registered) => {
+      return registered.orig;
+    }).indexOf(method);
+    if (index === -1) {
+      return;
+    }
+    state.registry[name].splice(index, 1);
+  }
+
+  // node_modules/@octokit/rest/node_modules/before-after-hook/index.js
+  var bind = Function.bind;
+  var bindable = bind.bind(bind);
+  function bindApi(hook2, state, name) {
+    const removeHookRef = bindable(removeHook, null).apply(
+      null,
+      name ? [state, name] : [state]
+    );
+    hook2.api = { remove: removeHookRef };
+    hook2.remove = removeHookRef;
+    ["before", "error", "after", "wrap"].forEach((kind) => {
+      const args = name ? [state, kind, name] : [state, kind];
+      hook2[kind] = hook2.api[kind] = bindable(addHook, null).apply(null, args);
+    });
+  }
+  function Singular() {
+    const singularHookName = Symbol("Singular");
+    const singularHookState = {
+      registry: {}
+    };
+    const singularHook = register.bind(null, singularHookState, singularHookName);
+    bindApi(singularHook, singularHookState, singularHookName);
+    return singularHook;
+  }
+  function Collection() {
+    const state = {
+      registry: {}
+    };
+    const hook2 = register.bind(null, state);
+    bindApi(hook2, state);
+    return hook2;
+  }
+  var before_after_hook_default = { Singular, Collection };
+
+  // node_modules/@octokit/rest/node_modules/@octokit/endpoint/dist-bundle/index.js
+  var VERSION = "0.0.0-development";
+  var userAgent = `octokit-endpoint.js/${VERSION} ${getUserAgent()}`;
+  var DEFAULTS = {
+    method: "GET",
+    baseUrl: "https://api.github.com",
+    headers: {
+      accept: "application/vnd.github.v3+json",
+      "user-agent": userAgent
+    },
+    mediaType: {
+      format: ""
+    }
+  };
+  function lowercaseKeys(object) {
+    if (!object) {
+      return {};
+    }
+    return Object.keys(object).reduce((newObj, key) => {
+      newObj[key.toLowerCase()] = object[key];
+      return newObj;
+    }, {});
+  }
+  function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+      return false;
+    if (Object.prototype.toString.call(value) !== "[object Object]")
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+      return true;
+    const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+    return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
+  }
+  function mergeDeep(defaults, options) {
+    const result = Object.assign({}, defaults);
+    Object.keys(options).forEach((key) => {
+      if (isPlainObject(options[key])) {
+        if (!(key in defaults))
+          Object.assign(result, { [key]: options[key] });
+        else
+          result[key] = mergeDeep(defaults[key], options[key]);
+      } else {
+        Object.assign(result, { [key]: options[key] });
+      }
+    });
+    return result;
+  }
+  function removeUndefinedProperties(obj) {
+    for (const key in obj) {
+      if (obj[key] === void 0) {
+        delete obj[key];
+      }
+    }
+    return obj;
+  }
+  function merge(defaults, route, options) {
+    if (typeof route === "string") {
+      let [method, url] = route.split(" ");
+      options = Object.assign(url ? { method, url } : { url: method }, options);
+    } else {
+      options = Object.assign({}, route);
+    }
+    options.headers = lowercaseKeys(options.headers);
+    removeUndefinedProperties(options);
+    removeUndefinedProperties(options.headers);
+    const mergedOptions = mergeDeep(defaults || {}, options);
+    if (options.url === "/graphql") {
+      if (defaults && defaults.mediaType.previews?.length) {
+        mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(
+          (preview) => !mergedOptions.mediaType.previews.includes(preview)
+        ).concat(mergedOptions.mediaType.previews);
+      }
+      mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, ""));
+    }
+    return mergedOptions;
+  }
+  function addQueryParameters(url, parameters) {
+    const separator = /\?/.test(url) ? "&" : "?";
+    const names = Object.keys(parameters);
+    if (names.length === 0) {
+      return url;
+    }
+    return url + separator + names.map((name) => {
+      if (name === "q") {
+        return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
+      }
+      return `${name}=${encodeURIComponent(parameters[name])}`;
+    }).join("&");
+  }
+  var urlVariableRegex = /\{[^}]+\}/g;
+  function removeNonChars(variableName) {
+    return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
+  }
+  function extractUrlVariableNames(url) {
+    const matches = url.match(urlVariableRegex);
+    if (!matches) {
+      return [];
+    }
+    return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
+  }
+  function omit(object, keysToOmit) {
+    const result = { __proto__: null };
+    for (const key of Object.keys(object)) {
+      if (keysToOmit.indexOf(key) === -1) {
+        result[key] = object[key];
+      }
+    }
+    return result;
+  }
+  function encodeReserved(str) {
+    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+      if (!/%[0-9A-Fa-f]/.test(part)) {
+        part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
+      }
+      return part;
+    }).join("");
+  }
+  function encodeUnreserved(str) {
+    return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+      return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+    });
+  }
+  function encodeValue(operator, value, key) {
+    value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
+    if (key) {
+      return encodeUnreserved(key) + "=" + value;
+    } else {
+      return value;
+    }
+  }
+  function isDefined(value) {
+    return value !== void 0 && value !== null;
+  }
+  function isKeyOperator(operator) {
+    return operator === ";" || operator === "&" || operator === "?";
+  }
+  function getValues(context, operator, key, modifier) {
+    var value = context[key], result = [];
+    if (isDefined(value) && value !== "") {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        value = value.toString();
+        if (modifier && modifier !== "*") {
+          value = value.substring(0, parseInt(modifier, 10));
+        }
+        result.push(
+          encodeValue(operator, value, isKeyOperator(operator) ? key : "")
+        );
+      } else {
+        if (modifier === "*") {
+          if (Array.isArray(value)) {
+            value.filter(isDefined).forEach(function(value2) {
+              result.push(
+                encodeValue(operator, value2, isKeyOperator(operator) ? key : "")
+              );
+            });
+          } else {
+            Object.keys(value).forEach(function(k) {
+              if (isDefined(value[k])) {
+                result.push(encodeValue(operator, value[k], k));
+              }
+            });
+          }
+        } else {
+          const tmp = [];
+          if (Array.isArray(value)) {
+            value.filter(isDefined).forEach(function(value2) {
+              tmp.push(encodeValue(operator, value2));
+            });
+          } else {
+            Object.keys(value).forEach(function(k) {
+              if (isDefined(value[k])) {
+                tmp.push(encodeUnreserved(k));
+                tmp.push(encodeValue(operator, value[k].toString()));
+              }
+            });
+          }
+          if (isKeyOperator(operator)) {
+            result.push(encodeUnreserved(key) + "=" + tmp.join(","));
+          } else if (tmp.length !== 0) {
+            result.push(tmp.join(","));
+          }
+        }
+      }
+    } else {
+      if (operator === ";") {
+        if (isDefined(value)) {
+          result.push(encodeUnreserved(key));
+        }
+      } else if (value === "" && (operator === "&" || operator === "?")) {
+        result.push(encodeUnreserved(key) + "=");
+      } else if (value === "") {
+        result.push("");
+      }
+    }
+    return result;
+  }
+  function parseUrl(template) {
+    return {
+      expand: expand.bind(null, template)
+    };
+  }
+  function expand(template, context) {
+    var operators = ["+", "#", ".", "/", ";", "?", "&"];
+    template = template.replace(
+      /\{([^\{\}]+)\}|([^\{\}]+)/g,
+      function(_, expression, literal) {
+        if (expression) {
+          let operator = "";
+          const values = [];
+          if (operators.indexOf(expression.charAt(0)) !== -1) {
+            operator = expression.charAt(0);
+            expression = expression.substr(1);
+          }
+          expression.split(/,/g).forEach(function(variable) {
+            var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+            values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+          });
+          if (operator && operator !== "+") {
+            var separator = ",";
+            if (operator === "?") {
+              separator = "&";
+            } else if (operator !== "#") {
+              separator = operator;
+            }
+            return (values.length !== 0 ? operator : "") + values.join(separator);
+          } else {
+            return values.join(",");
+          }
+        } else {
+          return encodeReserved(literal);
+        }
+      }
+    );
+    if (template === "/") {
+      return template;
+    } else {
+      return template.replace(/\/$/, "");
+    }
+  }
+  function parse(options) {
+    let method = options.method.toUpperCase();
+    let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
+    let headers = Object.assign({}, options.headers);
+    let body;
+    let parameters = omit(options, [
+      "method",
+      "baseUrl",
+      "url",
+      "headers",
+      "request",
+      "mediaType"
+    ]);
+    const urlVariableNames = extractUrlVariableNames(url);
+    url = parseUrl(url).expand(parameters);
+    if (!/^http/.test(url)) {
+      url = options.baseUrl + url;
+    }
+    const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
+    const remainingParameters = omit(parameters, omittedParameters);
+    const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
+    if (!isBinaryRequest) {
+      if (options.mediaType.format) {
+        headers.accept = headers.accept.split(/,/).map(
+          (format) => format.replace(
+            /application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,
+            `application/vnd$1$2.${options.mediaType.format}`
+          )
+        ).join(",");
+      }
+      if (url.endsWith("/graphql")) {
+        if (options.mediaType.previews?.length) {
+          const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
+          headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
+            const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
+            return `application/vnd.github.${preview}-preview${format}`;
+          }).join(",");
+        }
+      }
+    }
+    if (["GET", "HEAD"].includes(method)) {
+      url = addQueryParameters(url, remainingParameters);
+    } else {
+      if ("data" in remainingParameters) {
+        body = remainingParameters.data;
+      } else {
+        if (Object.keys(remainingParameters).length) {
+          body = remainingParameters;
+        }
+      }
+    }
+    if (!headers["content-type"] && typeof body !== "undefined") {
+      headers["content-type"] = "application/json; charset=utf-8";
+    }
+    if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
+      body = "";
+    }
+    return Object.assign(
+      { method, url, headers },
+      typeof body !== "undefined" ? { body } : null,
+      options.request ? { request: options.request } : null
+    );
+  }
+  function endpointWithDefaults(defaults, route, options) {
+    return parse(merge(defaults, route, options));
+  }
+  function withDefaults(oldDefaults, newDefaults) {
+    const DEFAULTS2 = merge(oldDefaults, newDefaults);
+    const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
+    return Object.assign(endpoint2, {
+      DEFAULTS: DEFAULTS2,
+      defaults: withDefaults.bind(null, DEFAULTS2),
+      merge: merge.bind(null, DEFAULTS2),
+      parse
+    });
+  }
+  var endpoint = withDefaults(null, DEFAULTS);
+
+  // node_modules/@octokit/rest/node_modules/@octokit/request-error/dist-src/index.js
+  var RequestError = class extends Error {
+    name;
+    /**
+     * http status code
+     */
+    status;
+    /**
+     * Request options that lead to the error.
+     */
+    request;
+    /**
+     * Response object if a response was received
+     */
+    response;
+    constructor(message, statusCode, options) {
+      super(message);
+      this.name = "HttpError";
+      this.status = Number.parseInt(statusCode);
+      if (Number.isNaN(this.status)) {
+        this.status = 0;
+      }
+      if ("response" in options) {
+        this.response = options.response;
+      }
+      const requestCopy = Object.assign({}, options.request);
+      if (options.request.headers.authorization) {
+        requestCopy.headers = Object.assign({}, options.request.headers, {
+          authorization: options.request.headers.authorization.replace(
+            / .*$/,
+            " [REDACTED]"
+          )
+        });
+      }
+      requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
+      this.request = requestCopy;
+    }
+  };
+
+  // node_modules/@octokit/rest/node_modules/@octokit/request/dist-bundle/index.js
+  var VERSION2 = "0.0.0-development";
+  var defaults_default = {
+    headers: {
+      "user-agent": `octokit-request.js/${VERSION2} ${getUserAgent()}`
+    }
+  };
+  function isPlainObject2(value) {
+    if (typeof value !== "object" || value === null) return false;
+    if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null) return true;
+    const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+    return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
+  }
+  async function fetchWrapper(requestOptions) {
+    const fetch = requestOptions.request?.fetch || globalThis.fetch;
+    if (!fetch) {
+      throw new Error(
+        "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
+      );
+    }
+    const log = requestOptions.request?.log || console;
+    const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
+    const body = isPlainObject2(requestOptions.body) || Array.isArray(requestOptions.body) ? JSON.stringify(requestOptions.body) : requestOptions.body;
+    const requestHeaders = Object.fromEntries(
+      Object.entries(requestOptions.headers).map(([name, value]) => [
+        name,
+        String(value)
+      ])
+    );
+    let fetchResponse;
+    try {
+      fetchResponse = await fetch(requestOptions.url, {
+        method: requestOptions.method,
+        body,
+        redirect: requestOptions.request?.redirect,
+        headers: requestHeaders,
+        signal: requestOptions.request?.signal,
+        // duplex must be set if request.body is ReadableStream or Async Iterables.
+        // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex.
+        ...requestOptions.body && { duplex: "half" }
+      });
+    } catch (error) {
+      let message = "Unknown Error";
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          error.status = 500;
+          throw error;
         }
-        else if (!['master', 'main', 'gh-pages'].includes(branch.name)) {
-            console.log(branch.name);
+        message = error.message;
+        if (error.name === "TypeError" && "cause" in error) {
+          if (error.cause instanceof Error) {
+            message = error.cause.message;
+          } else if (typeof error.cause === "string") {
+            message = error.cause;
+          }
         }
+      }
+      const requestError = new RequestError(message, 500, {
+        request: requestOptions
+      });
+      requestError.cause = error;
+      throw requestError;
+    }
+    const status = fetchResponse.status;
+    const url = fetchResponse.url;
+    const responseHeaders = {};
+    for (const [key, value] of fetchResponse.headers) {
+      responseHeaders[key] = value;
+    }
+    const octokitResponse = {
+      url,
+      status,
+      headers: responseHeaders,
+      data: ""
+    };
+    if ("deprecation" in responseHeaders) {
+      const matches = responseHeaders.link && responseHeaders.link.match(/<([^>]+)>; rel="deprecation"/);
+      const deprecationLink = matches && matches.pop();
+      log.warn(
+        `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
+      );
+    }
+    if (status === 204 || status === 205) {
+      return octokitResponse;
+    }
+    if (requestOptions.method === "HEAD") {
+      if (status < 400) {
+        return octokitResponse;
+      }
+      throw new RequestError(fetchResponse.statusText, status, {
+        response: octokitResponse,
+        request: requestOptions
+      });
+    }
+    if (status === 304) {
+      octokitResponse.data = await getResponseData(fetchResponse);
+      throw new RequestError("Not modified", status, {
+        response: octokitResponse,
+        request: requestOptions
+      });
+    }
+    if (status >= 400) {
+      octokitResponse.data = await getResponseData(fetchResponse);
+      throw new RequestError(toErrorMessage(octokitResponse.data), status, {
+        response: octokitResponse,
+        request: requestOptions
+      });
+    }
+    octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body;
+    return octokitResponse;
+  }
+  async function getResponseData(response) {
+    const contentType = response.headers.get("content-type");
+    if (/application\/json/.test(contentType)) {
+      return response.json().catch(() => response.text()).catch(() => "");
+    }
+    if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
+      return response.text();
+    }
+    return response.arrayBuffer();
+  }
+  function toErrorMessage(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return "Unknown error";
+    }
+    if ("message" in data) {
+      const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : "";
+      return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`;
+    }
+    return `Unknown error: ${JSON.stringify(data)}`;
+  }
+  function withDefaults2(oldEndpoint, newDefaults) {
+    const endpoint2 = oldEndpoint.defaults(newDefaults);
+    const newApi = function(route, parameters) {
+      const endpointOptions = endpoint2.merge(route, parameters);
+      if (!endpointOptions.request || !endpointOptions.request.hook) {
+        return fetchWrapper(endpoint2.parse(endpointOptions));
+      }
+      const request2 = (route2, parameters2) => {
+        return fetchWrapper(
+          endpoint2.parse(endpoint2.merge(route2, parameters2))
+        );
+      };
+      Object.assign(request2, {
+        endpoint: endpoint2,
+        defaults: withDefaults2.bind(null, endpoint2)
+      });
+      return endpointOptions.request.hook(request2, endpointOptions);
+    };
+    return Object.assign(newApi, {
+      endpoint: endpoint2,
+      defaults: withDefaults2.bind(null, endpoint2)
+    });
+  }
+  var request = withDefaults2(endpoint, defaults_default);
+
+  // node_modules/@octokit/rest/node_modules/@octokit/graphql/dist-bundle/index.js
+  var VERSION3 = "0.0.0-development";
+  function _buildMessageForResponseErrors(data) {
+    return `Request failed due to following response errors:
+` + data.errors.map((e) => ` - ${e.message}`).join("\n");
+  }
+  var GraphqlResponseError = class extends Error {
+    constructor(request2, headers, response) {
+      super(_buildMessageForResponseErrors(response));
+      this.request = request2;
+      this.headers = headers;
+      this.response = response;
+      this.errors = response.errors;
+      this.data = response.data;
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+    name = "GraphqlResponseError";
+    errors;
+    data;
+  };
+  var NON_VARIABLE_OPTIONS = [
+    "method",
+    "baseUrl",
+    "url",
+    "headers",
+    "request",
+    "query",
+    "mediaType"
+  ];
+  var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
+  var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
+  function graphql(request2, query, options) {
+    if (options) {
+      if (typeof query === "string" && "query" in options) {
+        return Promise.reject(
+          new Error(`[@octokit/graphql] "query" cannot be used as variable name`)
+        );
+      }
+      for (const key in options) {
+        if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key))
+          continue;
+        return Promise.reject(
+          new Error(
+            `[@octokit/graphql] "${key}" cannot be used as variable name`
+          )
+        );
+      }
+    }
+    const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
+    const requestOptions = Object.keys(
+      parsedOptions
+    ).reduce((result, key) => {
+      if (NON_VARIABLE_OPTIONS.includes(key)) {
+        result[key] = parsedOptions[key];
+        return result;
+      }
+      if (!result.variables) {
+        result.variables = {};
+      }
+      result.variables[key] = parsedOptions[key];
+      return result;
+    }, {});
+    const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
+    if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
+      requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
+    }
+    return request2(requestOptions).then((response) => {
+      if (response.data.errors) {
+        const headers = {};
+        for (const key of Object.keys(response.headers)) {
+          headers[key] = response.headers[key];
+        }
+        throw new GraphqlResponseError(
+          requestOptions,
+          headers,
+          response.data
+        );
+      }
+      return response.data.data;
+    });
+  }
+  function withDefaults3(request2, newDefaults) {
+    const newRequest = request2.defaults(newDefaults);
+    const newApi = (query, options) => {
+      return graphql(newRequest, query, options);
+    };
+    return Object.assign(newApi, {
+      defaults: withDefaults3.bind(null, newRequest),
+      endpoint: newRequest.endpoint
+    });
+  }
+  var graphql2 = withDefaults3(request, {
+    headers: {
+      "user-agent": `octokit-graphql.js/${VERSION3} ${getUserAgent()}`
+    },
+    method: "POST",
+    url: "/graphql"
+  });
+  function withCustomRequest(customRequest) {
+    return withDefaults3(customRequest, {
+      method: "POST",
+      url: "/graphql"
+    });
+  }
+
+  // node_modules/@octokit/rest/node_modules/@octokit/auth-token/dist-bundle/index.js
+  var REGEX_IS_INSTALLATION_LEGACY = /^v1\./;
+  var REGEX_IS_INSTALLATION = /^ghs_/;
+  var REGEX_IS_USER_TO_SERVER = /^ghu_/;
+  async function auth(token) {
+    const isApp = token.split(/\./).length === 3;
+    const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token);
+    const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token);
+    const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth";
+    return {
+      type: "token",
+      token,
+      tokenType
+    };
+  }
+  function withAuthorizationPrefix(token) {
+    if (token.split(/\./).length === 3) {
+      return `bearer ${token}`;
+    }
+    return `token ${token}`;
+  }
+  async function hook(token, request2, route, parameters) {
+    const endpoint2 = request2.endpoint.merge(
+      route,
+      parameters
+    );
+    endpoint2.headers.authorization = withAuthorizationPrefix(token);
+    return request2(endpoint2);
+  }
+  var createTokenAuth = function createTokenAuth2(token) {
+    if (!token) {
+      throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
+    }
+    if (typeof token !== "string") {
+      throw new Error(
+        "[@octokit/auth-token] Token passed to createTokenAuth is not a string"
+      );
+    }
+    token = token.replace(/^(token|bearer) +/i, "");
+    return Object.assign(auth.bind(null, token), {
+      hook: hook.bind(null, token)
+    });
+  };
+
+  // node_modules/@octokit/rest/node_modules/@octokit/core/dist-src/version.js
+  var VERSION4 = "6.1.2";
+
+  // node_modules/@octokit/rest/node_modules/@octokit/core/dist-src/index.js
+  var noop = () => {
+  };
+  var consoleWarn = console.warn.bind(console);
+  var consoleError = console.error.bind(console);
+  var userAgentTrail = `octokit-core.js/${VERSION4} ${getUserAgent()}`;
+  var Octokit = class {
+    static VERSION = VERSION4;
+    static defaults(defaults) {
+      const OctokitWithDefaults = class extends this {
+        constructor(...args) {
+          const options = args[0] || {};
+          if (typeof defaults === "function") {
+            super(defaults(options));
+            return;
+          }
+          super(
+            Object.assign(
+              {},
+              defaults,
+              options,
+              options.userAgent && defaults.userAgent ? {
+                userAgent: `${options.userAgent} ${defaults.userAgent}`
+              } : null
+            )
+          );
+        }
+      };
+      return OctokitWithDefaults;
+    }
+    static plugins = [];
+    /**
+     * Attach a plugin (or many) to your Octokit instance.
+     *
+     * @example
+     * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
+     */
+    static plugin(...newPlugins) {
+      const currentPlugins = this.plugins;
+      const NewOctokit = class extends this {
+        static plugins = currentPlugins.concat(
+          newPlugins.filter((plugin) => !currentPlugins.includes(plugin))
+        );
+      };
+      return NewOctokit;
+    }
+    constructor(options = {}) {
+      const hook2 = new before_after_hook_default.Collection();
+      const requestDefaults = {
+        baseUrl: request.endpoint.DEFAULTS.baseUrl,
+        headers: {},
+        request: Object.assign({}, options.request, {
+          // @ts-ignore internal usage only, no need to type
+          hook: hook2.bind(null, "request")
+        }),
+        mediaType: {
+          previews: [],
+          format: ""
+        }
+      };
+      requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail;
+      if (options.baseUrl) {
+        requestDefaults.baseUrl = options.baseUrl;
+      }
+      if (options.previews) {
+        requestDefaults.mediaType.previews = options.previews;
+      }
+      if (options.timeZone) {
+        requestDefaults.headers["time-zone"] = options.timeZone;
+      }
+      this.request = request.defaults(requestDefaults);
+      this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
+      this.log = Object.assign(
+        {
+          debug: noop,
+          info: noop,
+          warn: consoleWarn,
+          error: consoleError
+        },
+        options.log
+      );
+      this.hook = hook2;
+      if (!options.authStrategy) {
+        if (!options.auth) {
+          this.auth = async () => ({
+            type: "unauthenticated"
+          });
+        } else {
+          const auth2 = createTokenAuth(options.auth);
+          hook2.wrap("request", auth2.hook);
+          this.auth = auth2;
+        }
+      } else {
+        const { authStrategy, ...otherOptions } = options;
+        const auth2 = authStrategy(
+          Object.assign(
+            {
+              request: this.request,
+              log: this.log,
+              // we pass the current octokit instance as well as its constructor options
+              // to allow for authentication strategies that return a new octokit instance
+              // that shares the same internal state as the current one. The original
+              // requirement for this was the "event-octokit" authentication strategy
+              // of https://github.com/probot/octokit-auth-probot.
+              octokit: this,
+              octokitOptions: otherOptions
+            },
+            options.auth
+          )
+        );
+        hook2.wrap("request", auth2.hook);
+        this.auth = auth2;
+      }
+      const classConstructor = this.constructor;
+      for (let i = 0; i < classConstructor.plugins.length; ++i) {
+        Object.assign(this, classConstructor.plugins[i](this, options));
+      }
+    }
+    // assigned during constructor
+    request;
+    graphql;
+    log;
+    hook;
+    // TODO: type `octokit.auth` based on passed options.authStrategy
+    auth;
+  };
+
+  // node_modules/@octokit/rest/node_modules/@octokit/plugin-request-log/dist-src/version.js
+  var VERSION5 = "5.3.1";
+
+  // node_modules/@octokit/rest/node_modules/@octokit/plugin-request-log/dist-src/index.js
+  function requestLog(octokit2) {
+    octokit2.hook.wrap("request", (request2, options) => {
+      octokit2.log.debug("request", options);
+      const start = Date.now();
+      const requestOptions = octokit2.request.endpoint.parse(options);
+      const path2 = requestOptions.url.replace(options.baseUrl, "");
+      return request2(options).then((response) => {
+        const requestId = response.headers["x-github-request-id"];
+        octokit2.log.info(
+          `${requestOptions.method} ${path2} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
+        );
+        return response;
+      }).catch((error) => {
+        const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
+        octokit2.log.error(
+          `${requestOptions.method} ${path2} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
+        );
+        throw error;
+      });
+    });
+  }
+  requestLog.VERSION = VERSION5;
+
+  // node_modules/@octokit/plugin-paginate-rest/dist-web/index.js
+  var VERSION6 = "11.3.1";
+  function normalizePaginatedListResponse(response) {
+    if (!response.data) {
+      return {
+        ...response,
+        data: []
+      };
+    }
+    const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
+    if (!responseNeedsNormalization)
+      return response;
+    const incompleteResults = response.data.incomplete_results;
+    const repositorySelection = response.data.repository_selection;
+    const totalCount = response.data.total_count;
+    delete response.data.incomplete_results;
+    delete response.data.repository_selection;
+    delete response.data.total_count;
+    const namespaceKey = Object.keys(response.data)[0];
+    const data = response.data[namespaceKey];
+    response.data = data;
+    if (typeof incompleteResults !== "undefined") {
+      response.data.incomplete_results = incompleteResults;
+    }
+    if (typeof repositorySelection !== "undefined") {
+      response.data.repository_selection = repositorySelection;
+    }
+    response.data.total_count = totalCount;
+    return response;
+  }
+  function iterator(octokit2, route, parameters) {
+    const options = typeof route === "function" ? route.endpoint(parameters) : octokit2.request.endpoint(route, parameters);
+    const requestMethod = typeof route === "function" ? route : octokit2.request;
+    const method = options.method;
+    const headers = options.headers;
+    let url = options.url;
+    return {
+      [Symbol.asyncIterator]: () => ({
+        async next() {
+          if (!url)
+            return { done: true };
+          try {
+            const response = await requestMethod({ method, url, headers });
+            const normalizedResponse = normalizePaginatedListResponse(response);
+            url = ((normalizedResponse.headers.link || "").match(
+              /<([^>]+)>;\s*rel="next"/
+            ) || [])[1];
+            return { value: normalizedResponse };
+          } catch (error) {
+            if (error.status !== 409)
+              throw error;
+            url = "";
+            return {
+              value: {
+                status: 200,
+                headers: {},
+                data: []
+              }
+            };
+          }
+        }
+      })
+    };
+  }
+  function paginate(octokit2, route, parameters, mapFn) {
+    if (typeof parameters === "function") {
+      mapFn = parameters;
+      parameters = void 0;
+    }
+    return gather(
+      octokit2,
+      [],
+      iterator(octokit2, route, parameters)[Symbol.asyncIterator](),
+      mapFn
+    );
+  }
+  function gather(octokit2, results, iterator2, mapFn) {
+    return iterator2.next().then((result) => {
+      if (result.done) {
+        return results;
+      }
+      let earlyExit = false;
+      function done() {
+        earlyExit = true;
+      }
+      results = results.concat(
+        mapFn ? mapFn(result.value, done) : result.value.data
+      );
+      if (earlyExit) {
+        return results;
+      }
+      return gather(octokit2, results, iterator2, mapFn);
+    });
+  }
+  var composePaginateRest = Object.assign(paginate, {
+    iterator
+  });
+  function paginateRest(octokit2) {
+    return {
+      paginate: Object.assign(paginate.bind(null, octokit2), {
+        iterator: iterator.bind(null, octokit2)
+      })
+    };
+  }
+  paginateRest.VERSION = VERSION6;
+
+  // node_modules/@octokit/plugin-rest-endpoint-methods/dist-web/index.js
+  var VERSION7 = "13.2.2";
+  var Endpoints = {
+    actions: {
+      addCustomLabelsToSelfHostedRunnerForOrg: [
+        "POST /orgs/{org}/actions/runners/{runner_id}/labels"
+      ],
+      addCustomLabelsToSelfHostedRunnerForRepo: [
+        "POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
+      ],
+      addSelectedRepoToOrgSecret: [
+        "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      addSelectedRepoToOrgVariable: [
+        "PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"
+      ],
+      approveWorkflowRun: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"
+      ],
+      cancelWorkflowRun: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"
+      ],
+      createEnvironmentVariable: [
+        "POST /repos/{owner}/{repo}/environments/{environment_name}/variables"
+      ],
+      createOrUpdateEnvironmentSecret: [
+        "PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
+      ],
+      createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
+      createOrUpdateRepoSecret: [
+        "PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"
+      ],
+      createOrgVariable: ["POST /orgs/{org}/actions/variables"],
+      createRegistrationTokenForOrg: [
+        "POST /orgs/{org}/actions/runners/registration-token"
+      ],
+      createRegistrationTokenForRepo: [
+        "POST /repos/{owner}/{repo}/actions/runners/registration-token"
+      ],
+      createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
+      createRemoveTokenForRepo: [
+        "POST /repos/{owner}/{repo}/actions/runners/remove-token"
+      ],
+      createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"],
+      createWorkflowDispatch: [
+        "POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"
+      ],
+      deleteActionsCacheById: [
+        "DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"
+      ],
+      deleteActionsCacheByKey: [
+        "DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"
+      ],
+      deleteArtifact: [
+        "DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"
+      ],
+      deleteEnvironmentSecret: [
+        "DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
+      ],
+      deleteEnvironmentVariable: [
+        "DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
+      ],
+      deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
+      deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"],
+      deleteRepoSecret: [
+        "DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"
+      ],
+      deleteRepoVariable: [
+        "DELETE /repos/{owner}/{repo}/actions/variables/{name}"
+      ],
+      deleteSelfHostedRunnerFromOrg: [
+        "DELETE /orgs/{org}/actions/runners/{runner_id}"
+      ],
+      deleteSelfHostedRunnerFromRepo: [
+        "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"
+      ],
+      deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
+      deleteWorkflowRunLogs: [
+        "DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
+      ],
+      disableSelectedRepositoryGithubActionsOrganization: [
+        "DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"
+      ],
+      disableWorkflow: [
+        "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"
+      ],
+      downloadArtifact: [
+        "GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"
+      ],
+      downloadJobLogsForWorkflowRun: [
+        "GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"
+      ],
+      downloadWorkflowRunAttemptLogs: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"
+      ],
+      downloadWorkflowRunLogs: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
+      ],
+      enableSelectedRepositoryGithubActionsOrganization: [
+        "PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"
+      ],
+      enableWorkflow: [
+        "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"
+      ],
+      forceCancelWorkflowRun: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"
+      ],
+      generateRunnerJitconfigForOrg: [
+        "POST /orgs/{org}/actions/runners/generate-jitconfig"
+      ],
+      generateRunnerJitconfigForRepo: [
+        "POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"
+      ],
+      getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"],
+      getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"],
+      getActionsCacheUsageByRepoForOrg: [
+        "GET /orgs/{org}/actions/cache/usage-by-repository"
+      ],
+      getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"],
+      getAllowedActionsOrganization: [
+        "GET /orgs/{org}/actions/permissions/selected-actions"
+      ],
+      getAllowedActionsRepository: [
+        "GET /repos/{owner}/{repo}/actions/permissions/selected-actions"
+      ],
+      getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
+      getCustomOidcSubClaimForRepo: [
+        "GET /repos/{owner}/{repo}/actions/oidc/customization/sub"
+      ],
+      getEnvironmentPublicKey: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"
+      ],
+      getEnvironmentSecret: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
+      ],
+      getEnvironmentVariable: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
+      ],
+      getGithubActionsDefaultWorkflowPermissionsOrganization: [
+        "GET /orgs/{org}/actions/permissions/workflow"
+      ],
+      getGithubActionsDefaultWorkflowPermissionsRepository: [
+        "GET /repos/{owner}/{repo}/actions/permissions/workflow"
+      ],
+      getGithubActionsPermissionsOrganization: [
+        "GET /orgs/{org}/actions/permissions"
+      ],
+      getGithubActionsPermissionsRepository: [
+        "GET /repos/{owner}/{repo}/actions/permissions"
+      ],
+      getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
+      getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
+      getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
+      getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"],
+      getPendingDeploymentsForRun: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"
+      ],
+      getRepoPermissions: [
+        "GET /repos/{owner}/{repo}/actions/permissions",
+        {},
+        { renamed: ["actions", "getGithubActionsPermissionsRepository"] }
+      ],
+      getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
+      getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
+      getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"],
+      getReviewsForRun: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"
+      ],
+      getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
+      getSelfHostedRunnerForRepo: [
+        "GET /repos/{owner}/{repo}/actions/runners/{runner_id}"
+      ],
+      getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
+      getWorkflowAccessToRepository: [
+        "GET /repos/{owner}/{repo}/actions/permissions/access"
+      ],
+      getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
+      getWorkflowRunAttempt: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"
+      ],
+      getWorkflowRunUsage: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"
+      ],
+      getWorkflowUsage: [
+        "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"
+      ],
+      listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
+      listEnvironmentSecrets: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"
+      ],
+      listEnvironmentVariables: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/variables"
+      ],
+      listJobsForWorkflowRun: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"
+      ],
+      listJobsForWorkflowRunAttempt: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"
+      ],
+      listLabelsForSelfHostedRunnerForOrg: [
+        "GET /orgs/{org}/actions/runners/{runner_id}/labels"
+      ],
+      listLabelsForSelfHostedRunnerForRepo: [
+        "GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
+      ],
+      listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
+      listOrgVariables: ["GET /orgs/{org}/actions/variables"],
+      listRepoOrganizationSecrets: [
+        "GET /repos/{owner}/{repo}/actions/organization-secrets"
+      ],
+      listRepoOrganizationVariables: [
+        "GET /repos/{owner}/{repo}/actions/organization-variables"
+      ],
+      listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
+      listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"],
+      listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
+      listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
+      listRunnerApplicationsForRepo: [
+        "GET /repos/{owner}/{repo}/actions/runners/downloads"
+      ],
+      listSelectedReposForOrgSecret: [
+        "GET /orgs/{org}/actions/secrets/{secret_name}/repositories"
+      ],
+      listSelectedReposForOrgVariable: [
+        "GET /orgs/{org}/actions/variables/{name}/repositories"
+      ],
+      listSelectedRepositoriesEnabledGithubActionsOrganization: [
+        "GET /orgs/{org}/actions/permissions/repositories"
+      ],
+      listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
+      listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
+      listWorkflowRunArtifacts: [
+        "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"
+      ],
+      listWorkflowRuns: [
+        "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"
+      ],
+      listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
+      reRunJobForWorkflowRun: [
+        "POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"
+      ],
+      reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
+      reRunWorkflowFailedJobs: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"
+      ],
+      removeAllCustomLabelsFromSelfHostedRunnerForOrg: [
+        "DELETE /orgs/{org}/actions/runners/{runner_id}/labels"
+      ],
+      removeAllCustomLabelsFromSelfHostedRunnerForRepo: [
+        "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
+      ],
+      removeCustomLabelFromSelfHostedRunnerForOrg: [
+        "DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"
+      ],
+      removeCustomLabelFromSelfHostedRunnerForRepo: [
+        "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"
+      ],
+      removeSelectedRepoFromOrgSecret: [
+        "DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      removeSelectedRepoFromOrgVariable: [
+        "DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"
+      ],
+      reviewCustomGatesForRun: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"
+      ],
+      reviewPendingDeploymentsForRun: [
+        "POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"
+      ],
+      setAllowedActionsOrganization: [
+        "PUT /orgs/{org}/actions/permissions/selected-actions"
+      ],
+      setAllowedActionsRepository: [
+        "PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"
+      ],
+      setCustomLabelsForSelfHostedRunnerForOrg: [
+        "PUT /orgs/{org}/actions/runners/{runner_id}/labels"
+      ],
+      setCustomLabelsForSelfHostedRunnerForRepo: [
+        "PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
+      ],
+      setCustomOidcSubClaimForRepo: [
+        "PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"
+      ],
+      setGithubActionsDefaultWorkflowPermissionsOrganization: [
+        "PUT /orgs/{org}/actions/permissions/workflow"
+      ],
+      setGithubActionsDefaultWorkflowPermissionsRepository: [
+        "PUT /repos/{owner}/{repo}/actions/permissions/workflow"
+      ],
+      setGithubActionsPermissionsOrganization: [
+        "PUT /orgs/{org}/actions/permissions"
+      ],
+      setGithubActionsPermissionsRepository: [
+        "PUT /repos/{owner}/{repo}/actions/permissions"
+      ],
+      setSelectedReposForOrgSecret: [
+        "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"
+      ],
+      setSelectedReposForOrgVariable: [
+        "PUT /orgs/{org}/actions/variables/{name}/repositories"
+      ],
+      setSelectedRepositoriesEnabledGithubActionsOrganization: [
+        "PUT /orgs/{org}/actions/permissions/repositories"
+      ],
+      setWorkflowAccessToRepository: [
+        "PUT /repos/{owner}/{repo}/actions/permissions/access"
+      ],
+      updateEnvironmentVariable: [
+        "PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
+      ],
+      updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"],
+      updateRepoVariable: [
+        "PATCH /repos/{owner}/{repo}/actions/variables/{name}"
+      ]
+    },
+    activity: {
+      checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
+      deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
+      deleteThreadSubscription: [
+        "DELETE /notifications/threads/{thread_id}/subscription"
+      ],
+      getFeeds: ["GET /feeds"],
+      getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
+      getThread: ["GET /notifications/threads/{thread_id}"],
+      getThreadSubscriptionForAuthenticatedUser: [
+        "GET /notifications/threads/{thread_id}/subscription"
+      ],
+      listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
+      listNotificationsForAuthenticatedUser: ["GET /notifications"],
+      listOrgEventsForAuthenticatedUser: [
+        "GET /users/{username}/events/orgs/{org}"
+      ],
+      listPublicEvents: ["GET /events"],
+      listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
+      listPublicEventsForUser: ["GET /users/{username}/events/public"],
+      listPublicOrgEvents: ["GET /orgs/{org}/events"],
+      listReceivedEventsForUser: ["GET /users/{username}/received_events"],
+      listReceivedPublicEventsForUser: [
+        "GET /users/{username}/received_events/public"
+      ],
+      listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
+      listRepoNotificationsForAuthenticatedUser: [
+        "GET /repos/{owner}/{repo}/notifications"
+      ],
+      listReposStarredByAuthenticatedUser: ["GET /user/starred"],
+      listReposStarredByUser: ["GET /users/{username}/starred"],
+      listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
+      listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
+      listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
+      listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
+      markNotificationsAsRead: ["PUT /notifications"],
+      markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
+      markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"],
+      markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
+      setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
+      setThreadSubscription: [
+        "PUT /notifications/threads/{thread_id}/subscription"
+      ],
+      starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
+      unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
+    },
+    apps: {
+      addRepoToInstallation: [
+        "PUT /user/installations/{installation_id}/repositories/{repository_id}",
+        {},
+        { renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] }
+      ],
+      addRepoToInstallationForAuthenticatedUser: [
+        "PUT /user/installations/{installation_id}/repositories/{repository_id}"
+      ],
+      checkToken: ["POST /applications/{client_id}/token"],
+      createFromManifest: ["POST /app-manifests/{code}/conversions"],
+      createInstallationAccessToken: [
+        "POST /app/installations/{installation_id}/access_tokens"
+      ],
+      deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
+      deleteInstallation: ["DELETE /app/installations/{installation_id}"],
+      deleteToken: ["DELETE /applications/{client_id}/token"],
+      getAuthenticated: ["GET /app"],
+      getBySlug: ["GET /apps/{app_slug}"],
+      getInstallation: ["GET /app/installations/{installation_id}"],
+      getOrgInstallation: ["GET /orgs/{org}/installation"],
+      getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"],
+      getSubscriptionPlanForAccount: [
+        "GET /marketplace_listing/accounts/{account_id}"
+      ],
+      getSubscriptionPlanForAccountStubbed: [
+        "GET /marketplace_listing/stubbed/accounts/{account_id}"
+      ],
+      getUserInstallation: ["GET /users/{username}/installation"],
+      getWebhookConfigForApp: ["GET /app/hook/config"],
+      getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"],
+      listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
+      listAccountsForPlanStubbed: [
+        "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"
+      ],
+      listInstallationReposForAuthenticatedUser: [
+        "GET /user/installations/{installation_id}/repositories"
+      ],
+      listInstallationRequestsForAuthenticatedApp: [
+        "GET /app/installation-requests"
+      ],
+      listInstallations: ["GET /app/installations"],
+      listInstallationsForAuthenticatedUser: ["GET /user/installations"],
+      listPlans: ["GET /marketplace_listing/plans"],
+      listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
+      listReposAccessibleToInstallation: ["GET /installation/repositories"],
+      listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
+      listSubscriptionsForAuthenticatedUserStubbed: [
+        "GET /user/marketplace_purchases/stubbed"
+      ],
+      listWebhookDeliveries: ["GET /app/hook/deliveries"],
+      redeliverWebhookDelivery: [
+        "POST /app/hook/deliveries/{delivery_id}/attempts"
+      ],
+      removeRepoFromInstallation: [
+        "DELETE /user/installations/{installation_id}/repositories/{repository_id}",
+        {},
+        { renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] }
+      ],
+      removeRepoFromInstallationForAuthenticatedUser: [
+        "DELETE /user/installations/{installation_id}/repositories/{repository_id}"
+      ],
+      resetToken: ["PATCH /applications/{client_id}/token"],
+      revokeInstallationAccessToken: ["DELETE /installation/token"],
+      scopeToken: ["POST /applications/{client_id}/token/scoped"],
+      suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
+      unsuspendInstallation: [
+        "DELETE /app/installations/{installation_id}/suspended"
+      ],
+      updateWebhookConfigForApp: ["PATCH /app/hook/config"]
+    },
+    billing: {
+      getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"],
+      getGithubActionsBillingUser: [
+        "GET /users/{username}/settings/billing/actions"
+      ],
+      getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"],
+      getGithubPackagesBillingUser: [
+        "GET /users/{username}/settings/billing/packages"
+      ],
+      getSharedStorageBillingOrg: [
+        "GET /orgs/{org}/settings/billing/shared-storage"
+      ],
+      getSharedStorageBillingUser: [
+        "GET /users/{username}/settings/billing/shared-storage"
+      ]
+    },
+    checks: {
+      create: ["POST /repos/{owner}/{repo}/check-runs"],
+      createSuite: ["POST /repos/{owner}/{repo}/check-suites"],
+      get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],
+      getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],
+      listAnnotations: [
+        "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"
+      ],
+      listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],
+      listForSuite: [
+        "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"
+      ],
+      listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],
+      rerequestRun: [
+        "POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"
+      ],
+      rerequestSuite: [
+        "POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"
+      ],
+      setSuitesPreferences: [
+        "PATCH /repos/{owner}/{repo}/check-suites/preferences"
+      ],
+      update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]
+    },
+    codeScanning: {
+      deleteAnalysis: [
+        "DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"
+      ],
+      getAlert: [
+        "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",
+        {},
+        { renamedParameters: { alert_id: "alert_number" } }
+      ],
+      getAnalysis: [
+        "GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"
+      ],
+      getCodeqlDatabase: [
+        "GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"
+      ],
+      getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"],
+      getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],
+      listAlertInstances: [
+        "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"
+      ],
+      listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"],
+      listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
+      listAlertsInstances: [
+        "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",
+        {},
+        { renamed: ["codeScanning", "listAlertInstances"] }
+      ],
+      listCodeqlDatabases: [
+        "GET /repos/{owner}/{repo}/code-scanning/codeql/databases"
+      ],
+      listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"],
+      updateAlert: [
+        "PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"
+      ],
+      updateDefaultSetup: [
+        "PATCH /repos/{owner}/{repo}/code-scanning/default-setup"
+      ],
+      uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"]
+    },
+    codesOfConduct: {
+      getAllCodesOfConduct: ["GET /codes_of_conduct"],
+      getConductCode: ["GET /codes_of_conduct/{key}"]
+    },
+    codespaces: {
+      addRepositoryForSecretForAuthenticatedUser: [
+        "PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      addSelectedRepoToOrgSecret: [
+        "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      checkPermissionsForDevcontainer: [
+        "GET /repos/{owner}/{repo}/codespaces/permissions_check"
+      ],
+      codespaceMachinesForAuthenticatedUser: [
+        "GET /user/codespaces/{codespace_name}/machines"
+      ],
+      createForAuthenticatedUser: ["POST /user/codespaces"],
+      createOrUpdateOrgSecret: [
+        "PUT /orgs/{org}/codespaces/secrets/{secret_name}"
+      ],
+      createOrUpdateRepoSecret: [
+        "PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
+      ],
+      createOrUpdateSecretForAuthenticatedUser: [
+        "PUT /user/codespaces/secrets/{secret_name}"
+      ],
+      createWithPrForAuthenticatedUser: [
+        "POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"
+      ],
+      createWithRepoForAuthenticatedUser: [
+        "POST /repos/{owner}/{repo}/codespaces"
+      ],
+      deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"],
+      deleteFromOrganization: [
+        "DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"
+      ],
+      deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"],
+      deleteRepoSecret: [
+        "DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
+      ],
+      deleteSecretForAuthenticatedUser: [
+        "DELETE /user/codespaces/secrets/{secret_name}"
+      ],
+      exportForAuthenticatedUser: [
+        "POST /user/codespaces/{codespace_name}/exports"
+      ],
+      getCodespacesForUserInOrg: [
+        "GET /orgs/{org}/members/{username}/codespaces"
+      ],
+      getExportDetailsForAuthenticatedUser: [
+        "GET /user/codespaces/{codespace_name}/exports/{export_id}"
+      ],
+      getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"],
+      getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"],
+      getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"],
+      getPublicKeyForAuthenticatedUser: [
+        "GET /user/codespaces/secrets/public-key"
+      ],
+      getRepoPublicKey: [
+        "GET /repos/{owner}/{repo}/codespaces/secrets/public-key"
+      ],
+      getRepoSecret: [
+        "GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
+      ],
+      getSecretForAuthenticatedUser: [
+        "GET /user/codespaces/secrets/{secret_name}"
+      ],
+      listDevcontainersInRepositoryForAuthenticatedUser: [
+        "GET /repos/{owner}/{repo}/codespaces/devcontainers"
+      ],
+      listForAuthenticatedUser: ["GET /user/codespaces"],
+      listInOrganization: [
+        "GET /orgs/{org}/codespaces",
+        {},
+        { renamedParameters: { org_id: "org" } }
+      ],
+      listInRepositoryForAuthenticatedUser: [
+        "GET /repos/{owner}/{repo}/codespaces"
+      ],
+      listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"],
+      listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"],
+      listRepositoriesForSecretForAuthenticatedUser: [
+        "GET /user/codespaces/secrets/{secret_name}/repositories"
+      ],
+      listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"],
+      listSelectedReposForOrgSecret: [
+        "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"
+      ],
+      preFlightWithRepoForAuthenticatedUser: [
+        "GET /repos/{owner}/{repo}/codespaces/new"
+      ],
+      publishForAuthenticatedUser: [
+        "POST /user/codespaces/{codespace_name}/publish"
+      ],
+      removeRepositoryForSecretForAuthenticatedUser: [
+        "DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      removeSelectedRepoFromOrgSecret: [
+        "DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      repoMachinesForAuthenticatedUser: [
+        "GET /repos/{owner}/{repo}/codespaces/machines"
+      ],
+      setRepositoriesForSecretForAuthenticatedUser: [
+        "PUT /user/codespaces/secrets/{secret_name}/repositories"
+      ],
+      setSelectedReposForOrgSecret: [
+        "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"
+      ],
+      startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"],
+      stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"],
+      stopInOrganization: [
+        "POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"
+      ],
+      updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"]
+    },
+    copilot: {
+      addCopilotSeatsForTeams: [
+        "POST /orgs/{org}/copilot/billing/selected_teams"
+      ],
+      addCopilotSeatsForUsers: [
+        "POST /orgs/{org}/copilot/billing/selected_users"
+      ],
+      cancelCopilotSeatAssignmentForTeams: [
+        "DELETE /orgs/{org}/copilot/billing/selected_teams"
+      ],
+      cancelCopilotSeatAssignmentForUsers: [
+        "DELETE /orgs/{org}/copilot/billing/selected_users"
+      ],
+      getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"],
+      getCopilotSeatDetailsForUser: [
+        "GET /orgs/{org}/members/{username}/copilot"
+      ],
+      listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"],
+      usageMetricsForEnterprise: ["GET /enterprises/{enterprise}/copilot/usage"],
+      usageMetricsForOrg: ["GET /orgs/{org}/copilot/usage"],
+      usageMetricsForTeam: ["GET /orgs/{org}/team/{team_slug}/copilot/usage"]
+    },
+    dependabot: {
+      addSelectedRepoToOrgSecret: [
+        "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      createOrUpdateOrgSecret: [
+        "PUT /orgs/{org}/dependabot/secrets/{secret_name}"
+      ],
+      createOrUpdateRepoSecret: [
+        "PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
+      ],
+      deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"],
+      deleteRepoSecret: [
+        "DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
+      ],
+      getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],
+      getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"],
+      getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"],
+      getRepoPublicKey: [
+        "GET /repos/{owner}/{repo}/dependabot/secrets/public-key"
+      ],
+      getRepoSecret: [
+        "GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
+      ],
+      listAlertsForEnterprise: [
+        "GET /enterprises/{enterprise}/dependabot/alerts"
+      ],
+      listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"],
+      listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"],
+      listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"],
+      listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"],
+      listSelectedReposForOrgSecret: [
+        "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"
+      ],
+      removeSelectedRepoFromOrgSecret: [
+        "DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"
+      ],
+      setSelectedReposForOrgSecret: [
+        "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"
+      ],
+      updateAlert: [
+        "PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"
+      ]
+    },
+    dependencyGraph: {
+      createRepositorySnapshot: [
+        "POST /repos/{owner}/{repo}/dependency-graph/snapshots"
+      ],
+      diffRange: [
+        "GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"
+      ],
+      exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"]
+    },
+    emojis: { get: ["GET /emojis"] },
+    gists: {
+      checkIsStarred: ["GET /gists/{gist_id}/star"],
+      create: ["POST /gists"],
+      createComment: ["POST /gists/{gist_id}/comments"],
+      delete: ["DELETE /gists/{gist_id}"],
+      deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
+      fork: ["POST /gists/{gist_id}/forks"],
+      get: ["GET /gists/{gist_id}"],
+      getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
+      getRevision: ["GET /gists/{gist_id}/{sha}"],
+      list: ["GET /gists"],
+      listComments: ["GET /gists/{gist_id}/comments"],
+      listCommits: ["GET /gists/{gist_id}/commits"],
+      listForUser: ["GET /users/{username}/gists"],
+      listForks: ["GET /gists/{gist_id}/forks"],
+      listPublic: ["GET /gists/public"],
+      listStarred: ["GET /gists/starred"],
+      star: ["PUT /gists/{gist_id}/star"],
+      unstar: ["DELETE /gists/{gist_id}/star"],
+      update: ["PATCH /gists/{gist_id}"],
+      updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
+    },
+    git: {
+      createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
+      createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
+      createRef: ["POST /repos/{owner}/{repo}/git/refs"],
+      createTag: ["POST /repos/{owner}/{repo}/git/tags"],
+      createTree: ["POST /repos/{owner}/{repo}/git/trees"],
+      deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
+      getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
+      getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
+      getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
+      getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
+      getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
+      listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
+      updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
+    },
+    gitignore: {
+      getAllTemplates: ["GET /gitignore/templates"],
+      getTemplate: ["GET /gitignore/templates/{name}"]
+    },
+    interactions: {
+      getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"],
+      getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
+      getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
+      getRestrictionsForYourPublicRepos: [
+        "GET /user/interaction-limits",
+        {},
+        { renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] }
+      ],
+      removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"],
+      removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
+      removeRestrictionsForRepo: [
+        "DELETE /repos/{owner}/{repo}/interaction-limits"
+      ],
+      removeRestrictionsForYourPublicRepos: [
+        "DELETE /user/interaction-limits",
+        {},
+        { renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] }
+      ],
+      setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"],
+      setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
+      setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
+      setRestrictionsForYourPublicRepos: [
+        "PUT /user/interaction-limits",
+        {},
+        { renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] }
+      ]
+    },
+    issues: {
+      addAssignees: [
+        "POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"
+      ],
+      addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
+      checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
+      checkUserCanBeAssignedToIssue: [
+        "GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"
+      ],
+      create: ["POST /repos/{owner}/{repo}/issues"],
+      createComment: [
+        "POST /repos/{owner}/{repo}/issues/{issue_number}/comments"
+      ],
+      createLabel: ["POST /repos/{owner}/{repo}/labels"],
+      createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
+      deleteComment: [
+        "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"
+      ],
+      deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
+      deleteMilestone: [
+        "DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"
+      ],
+      get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
+      getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
+      getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
+      getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
+      getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
+      list: ["GET /issues"],
+      listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
+      listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
+      listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
+      listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
+      listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
+      listEventsForTimeline: [
+        "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"
+      ],
+      listForAuthenticatedUser: ["GET /user/issues"],
+      listForOrg: ["GET /orgs/{org}/issues"],
+      listForRepo: ["GET /repos/{owner}/{repo}/issues"],
+      listLabelsForMilestone: [
+        "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"
+      ],
+      listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
+      listLabelsOnIssue: [
+        "GET /repos/{owner}/{repo}/issues/{issue_number}/labels"
+      ],
+      listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
+      lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
+      removeAllLabels: [
+        "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"
+      ],
+      removeAssignees: [
+        "DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"
+      ],
+      removeLabel: [
+        "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"
+      ],
+      setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
+      unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
+      update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
+      updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
+      updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
+      updateMilestone: [
+        "PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"
+      ]
+    },
+    licenses: {
+      get: ["GET /licenses/{license}"],
+      getAllCommonlyUsed: ["GET /licenses"],
+      getForRepo: ["GET /repos/{owner}/{repo}/license"]
+    },
+    markdown: {
+      render: ["POST /markdown"],
+      renderRaw: [
+        "POST /markdown/raw",
+        { headers: { "content-type": "text/plain; charset=utf-8" } }
+      ]
+    },
+    meta: {
+      get: ["GET /meta"],
+      getAllVersions: ["GET /versions"],
+      getOctocat: ["GET /octocat"],
+      getZen: ["GET /zen"],
+      root: ["GET /"]
+    },
+    migrations: {
+      deleteArchiveForAuthenticatedUser: [
+        "DELETE /user/migrations/{migration_id}/archive"
+      ],
+      deleteArchiveForOrg: [
+        "DELETE /orgs/{org}/migrations/{migration_id}/archive"
+      ],
+      downloadArchiveForOrg: [
+        "GET /orgs/{org}/migrations/{migration_id}/archive"
+      ],
+      getArchiveForAuthenticatedUser: [
+        "GET /user/migrations/{migration_id}/archive"
+      ],
+      getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"],
+      getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"],
+      listForAuthenticatedUser: ["GET /user/migrations"],
+      listForOrg: ["GET /orgs/{org}/migrations"],
+      listReposForAuthenticatedUser: [
+        "GET /user/migrations/{migration_id}/repositories"
+      ],
+      listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"],
+      listReposForUser: [
+        "GET /user/migrations/{migration_id}/repositories",
+        {},
+        { renamed: ["migrations", "listReposForAuthenticatedUser"] }
+      ],
+      startForAuthenticatedUser: ["POST /user/migrations"],
+      startForOrg: ["POST /orgs/{org}/migrations"],
+      unlockRepoForAuthenticatedUser: [
+        "DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"
+      ],
+      unlockRepoForOrg: [
+        "DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"
+      ]
+    },
+    oidc: {
+      getOidcCustomSubTemplateForOrg: [
+        "GET /orgs/{org}/actions/oidc/customization/sub"
+      ],
+      updateOidcCustomSubTemplateForOrg: [
+        "PUT /orgs/{org}/actions/oidc/customization/sub"
+      ]
+    },
+    orgs: {
+      addSecurityManagerTeam: [
+        "PUT /orgs/{org}/security-managers/teams/{team_slug}"
+      ],
+      assignTeamToOrgRole: [
+        "PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"
+      ],
+      assignUserToOrgRole: [
+        "PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"
+      ],
+      blockUser: ["PUT /orgs/{org}/blocks/{username}"],
+      cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"],
+      checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
+      checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
+      checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
+      convertMemberToOutsideCollaborator: [
+        "PUT /orgs/{org}/outside_collaborators/{username}"
+      ],
+      createCustomOrganizationRole: ["POST /orgs/{org}/organization-roles"],
+      createInvitation: ["POST /orgs/{org}/invitations"],
+      createOrUpdateCustomProperties: ["PATCH /orgs/{org}/properties/schema"],
+      createOrUpdateCustomPropertiesValuesForRepos: [
+        "PATCH /orgs/{org}/properties/values"
+      ],
+      createOrUpdateCustomProperty: [
+        "PUT /orgs/{org}/properties/schema/{custom_property_name}"
+      ],
+      createWebhook: ["POST /orgs/{org}/hooks"],
+      delete: ["DELETE /orgs/{org}"],
+      deleteCustomOrganizationRole: [
+        "DELETE /orgs/{org}/organization-roles/{role_id}"
+      ],
+      deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
+      enableOrDisableSecurityProductOnAllOrgRepos: [
+        "POST /orgs/{org}/{security_product}/{enablement}"
+      ],
+      get: ["GET /orgs/{org}"],
+      getAllCustomProperties: ["GET /orgs/{org}/properties/schema"],
+      getCustomProperty: [
+        "GET /orgs/{org}/properties/schema/{custom_property_name}"
+      ],
+      getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
+      getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
+      getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"],
+      getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
+      getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"],
+      getWebhookDelivery: [
+        "GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"
+      ],
+      list: ["GET /organizations"],
+      listAppInstallations: ["GET /orgs/{org}/installations"],
+      listBlockedUsers: ["GET /orgs/{org}/blocks"],
+      listCustomPropertiesValuesForRepos: ["GET /orgs/{org}/properties/values"],
+      listFailedInvitations: ["GET /orgs/{org}/failed_invitations"],
+      listForAuthenticatedUser: ["GET /user/orgs"],
+      listForUser: ["GET /users/{username}/orgs"],
+      listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
+      listMembers: ["GET /orgs/{org}/members"],
+      listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
+      listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"],
+      listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"],
+      listOrgRoles: ["GET /orgs/{org}/organization-roles"],
+      listOrganizationFineGrainedPermissions: [
+        "GET /orgs/{org}/organization-fine-grained-permissions"
+      ],
+      listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
+      listPatGrantRepositories: [
+        "GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"
+      ],
+      listPatGrantRequestRepositories: [
+        "GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"
+      ],
+      listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"],
+      listPatGrants: ["GET /orgs/{org}/personal-access-tokens"],
+      listPendingInvitations: ["GET /orgs/{org}/invitations"],
+      listPublicMembers: ["GET /orgs/{org}/public_members"],
+      listSecurityManagerTeams: ["GET /orgs/{org}/security-managers"],
+      listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"],
+      listWebhooks: ["GET /orgs/{org}/hooks"],
+      patchCustomOrganizationRole: [
+        "PATCH /orgs/{org}/organization-roles/{role_id}"
+      ],
+      pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
+      redeliverWebhookDelivery: [
+        "POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"
+      ],
+      removeCustomProperty: [
+        "DELETE /orgs/{org}/properties/schema/{custom_property_name}"
+      ],
+      removeMember: ["DELETE /orgs/{org}/members/{username}"],
+      removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
+      removeOutsideCollaborator: [
+        "DELETE /orgs/{org}/outside_collaborators/{username}"
+      ],
+      removePublicMembershipForAuthenticatedUser: [
+        "DELETE /orgs/{org}/public_members/{username}"
+      ],
+      removeSecurityManagerTeam: [
+        "DELETE /orgs/{org}/security-managers/teams/{team_slug}"
+      ],
+      reviewPatGrantRequest: [
+        "POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"
+      ],
+      reviewPatGrantRequestsInBulk: [
+        "POST /orgs/{org}/personal-access-token-requests"
+      ],
+      revokeAllOrgRolesTeam: [
+        "DELETE /orgs/{org}/organization-roles/teams/{team_slug}"
+      ],
+      revokeAllOrgRolesUser: [
+        "DELETE /orgs/{org}/organization-roles/users/{username}"
+      ],
+      revokeOrgRoleTeam: [
+        "DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"
+      ],
+      revokeOrgRoleUser: [
+        "DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"
+      ],
+      setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
+      setPublicMembershipForAuthenticatedUser: [
+        "PUT /orgs/{org}/public_members/{username}"
+      ],
+      unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
+      update: ["PATCH /orgs/{org}"],
+      updateMembershipForAuthenticatedUser: [
+        "PATCH /user/memberships/orgs/{org}"
+      ],
+      updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"],
+      updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"],
+      updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"],
+      updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"]
+    },
+    packages: {
+      deletePackageForAuthenticatedUser: [
+        "DELETE /user/packages/{package_type}/{package_name}"
+      ],
+      deletePackageForOrg: [
+        "DELETE /orgs/{org}/packages/{package_type}/{package_name}"
+      ],
+      deletePackageForUser: [
+        "DELETE /users/{username}/packages/{package_type}/{package_name}"
+      ],
+      deletePackageVersionForAuthenticatedUser: [
+        "DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      deletePackageVersionForOrg: [
+        "DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      deletePackageVersionForUser: [
+        "DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      getAllPackageVersionsForAPackageOwnedByAnOrg: [
+        "GET /orgs/{org}/packages/{package_type}/{package_name}/versions",
+        {},
+        { renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] }
+      ],
+      getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [
+        "GET /user/packages/{package_type}/{package_name}/versions",
+        {},
+        {
+          renamed: [
+            "packages",
+            "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"
+          ]
+        }
+      ],
+      getAllPackageVersionsForPackageOwnedByAuthenticatedUser: [
+        "GET /user/packages/{package_type}/{package_name}/versions"
+      ],
+      getAllPackageVersionsForPackageOwnedByOrg: [
+        "GET /orgs/{org}/packages/{package_type}/{package_name}/versions"
+      ],
+      getAllPackageVersionsForPackageOwnedByUser: [
+        "GET /users/{username}/packages/{package_type}/{package_name}/versions"
+      ],
+      getPackageForAuthenticatedUser: [
+        "GET /user/packages/{package_type}/{package_name}"
+      ],
+      getPackageForOrganization: [
+        "GET /orgs/{org}/packages/{package_type}/{package_name}"
+      ],
+      getPackageForUser: [
+        "GET /users/{username}/packages/{package_type}/{package_name}"
+      ],
+      getPackageVersionForAuthenticatedUser: [
+        "GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      getPackageVersionForOrganization: [
+        "GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      getPackageVersionForUser: [
+        "GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"
+      ],
+      listDockerMigrationConflictingPackagesForAuthenticatedUser: [
+        "GET /user/docker/conflicts"
+      ],
+      listDockerMigrationConflictingPackagesForOrganization: [
+        "GET /orgs/{org}/docker/conflicts"
+      ],
+      listDockerMigrationConflictingPackagesForUser: [
+        "GET /users/{username}/docker/conflicts"
+      ],
+      listPackagesForAuthenticatedUser: ["GET /user/packages"],
+      listPackagesForOrganization: ["GET /orgs/{org}/packages"],
+      listPackagesForUser: ["GET /users/{username}/packages"],
+      restorePackageForAuthenticatedUser: [
+        "POST /user/packages/{package_type}/{package_name}/restore{?token}"
+      ],
+      restorePackageForOrg: [
+        "POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"
+      ],
+      restorePackageForUser: [
+        "POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"
+      ],
+      restorePackageVersionForAuthenticatedUser: [
+        "POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
+      ],
+      restorePackageVersionForOrg: [
+        "POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
+      ],
+      restorePackageVersionForUser: [
+        "POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
+      ]
+    },
+    projects: {
+      addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}"],
+      createCard: ["POST /projects/columns/{column_id}/cards"],
+      createColumn: ["POST /projects/{project_id}/columns"],
+      createForAuthenticatedUser: ["POST /user/projects"],
+      createForOrg: ["POST /orgs/{org}/projects"],
+      createForRepo: ["POST /repos/{owner}/{repo}/projects"],
+      delete: ["DELETE /projects/{project_id}"],
+      deleteCard: ["DELETE /projects/columns/cards/{card_id}"],
+      deleteColumn: ["DELETE /projects/columns/{column_id}"],
+      get: ["GET /projects/{project_id}"],
+      getCard: ["GET /projects/columns/cards/{card_id}"],
+      getColumn: ["GET /projects/columns/{column_id}"],
+      getPermissionForUser: [
+        "GET /projects/{project_id}/collaborators/{username}/permission"
+      ],
+      listCards: ["GET /projects/columns/{column_id}/cards"],
+      listCollaborators: ["GET /projects/{project_id}/collaborators"],
+      listColumns: ["GET /projects/{project_id}/columns"],
+      listForOrg: ["GET /orgs/{org}/projects"],
+      listForRepo: ["GET /repos/{owner}/{repo}/projects"],
+      listForUser: ["GET /users/{username}/projects"],
+      moveCard: ["POST /projects/columns/cards/{card_id}/moves"],
+      moveColumn: ["POST /projects/columns/{column_id}/moves"],
+      removeCollaborator: [
+        "DELETE /projects/{project_id}/collaborators/{username}"
+      ],
+      update: ["PATCH /projects/{project_id}"],
+      updateCard: ["PATCH /projects/columns/cards/{card_id}"],
+      updateColumn: ["PATCH /projects/columns/{column_id}"]
+    },
+    pulls: {
+      checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
+      create: ["POST /repos/{owner}/{repo}/pulls"],
+      createReplyForReviewComment: [
+        "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"
+      ],
+      createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
+      createReviewComment: [
+        "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"
+      ],
+      deletePendingReview: [
+        "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
+      ],
+      deleteReviewComment: [
+        "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"
+      ],
+      dismissReview: [
+        "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"
+      ],
+      get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
+      getReview: [
+        "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
+      ],
+      getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
+      list: ["GET /repos/{owner}/{repo}/pulls"],
+      listCommentsForReview: [
+        "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"
+      ],
+      listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
+      listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
+      listRequestedReviewers: [
+        "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
+      ],
+      listReviewComments: [
+        "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"
+      ],
+      listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
+      listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
+      merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
+      removeRequestedReviewers: [
+        "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
+      ],
+      requestReviewers: [
+        "POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
+      ],
+      submitReview: [
+        "POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"
+      ],
+      update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
+      updateBranch: [
+        "PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"
+      ],
+      updateReview: [
+        "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
+      ],
+      updateReviewComment: [
+        "PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"
+      ]
+    },
+    rateLimit: { get: ["GET /rate_limit"] },
+    reactions: {
+      createForCommitComment: [
+        "POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"
+      ],
+      createForIssue: [
+        "POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"
+      ],
+      createForIssueComment: [
+        "POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"
+      ],
+      createForPullRequestReviewComment: [
+        "POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"
+      ],
+      createForRelease: [
+        "POST /repos/{owner}/{repo}/releases/{release_id}/reactions"
+      ],
+      createForTeamDiscussionCommentInOrg: [
+        "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"
+      ],
+      createForTeamDiscussionInOrg: [
+        "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"
+      ],
+      deleteForCommitComment: [
+        "DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"
+      ],
+      deleteForIssue: [
+        "DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"
+      ],
+      deleteForIssueComment: [
+        "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"
+      ],
+      deleteForPullRequestComment: [
+        "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"
+      ],
+      deleteForRelease: [
+        "DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"
+      ],
+      deleteForTeamDiscussion: [
+        "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"
+      ],
+      deleteForTeamDiscussionComment: [
+        "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"
+      ],
+      listForCommitComment: [
+        "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"
+      ],
+      listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"],
+      listForIssueComment: [
+        "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"
+      ],
+      listForPullRequestReviewComment: [
+        "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"
+      ],
+      listForRelease: [
+        "GET /repos/{owner}/{repo}/releases/{release_id}/reactions"
+      ],
+      listForTeamDiscussionCommentInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"
+      ],
+      listForTeamDiscussionInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"
+      ]
+    },
+    repos: {
+      acceptInvitation: [
+        "PATCH /user/repository_invitations/{invitation_id}",
+        {},
+        { renamed: ["repos", "acceptInvitationForAuthenticatedUser"] }
+      ],
+      acceptInvitationForAuthenticatedUser: [
+        "PATCH /user/repository_invitations/{invitation_id}"
+      ],
+      addAppAccessRestrictions: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
+        {},
+        { mapToData: "apps" }
+      ],
+      addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
+      addStatusCheckContexts: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
+        {},
+        { mapToData: "contexts" }
+      ],
+      addTeamAccessRestrictions: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
+        {},
+        { mapToData: "teams" }
+      ],
+      addUserAccessRestrictions: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
+        {},
+        { mapToData: "users" }
+      ],
+      cancelPagesDeployment: [
+        "POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"
+      ],
+      checkAutomatedSecurityFixes: [
+        "GET /repos/{owner}/{repo}/automated-security-fixes"
+      ],
+      checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
+      checkPrivateVulnerabilityReporting: [
+        "GET /repos/{owner}/{repo}/private-vulnerability-reporting"
+      ],
+      checkVulnerabilityAlerts: [
+        "GET /repos/{owner}/{repo}/vulnerability-alerts"
+      ],
+      codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"],
+      compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
+      compareCommitsWithBasehead: [
+        "GET /repos/{owner}/{repo}/compare/{basehead}"
+      ],
+      createAutolink: ["POST /repos/{owner}/{repo}/autolinks"],
+      createCommitComment: [
+        "POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"
+      ],
+      createCommitSignatureProtection: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
+      ],
+      createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
+      createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
+      createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
+      createDeploymentBranchPolicy: [
+        "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"
+      ],
+      createDeploymentProtectionRule: [
+        "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"
+      ],
+      createDeploymentStatus: [
+        "POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"
+      ],
+      createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
+      createForAuthenticatedUser: ["POST /user/repos"],
+      createFork: ["POST /repos/{owner}/{repo}/forks"],
+      createInOrg: ["POST /orgs/{org}/repos"],
+      createOrUpdateCustomPropertiesValues: [
+        "PATCH /repos/{owner}/{repo}/properties/values"
+      ],
+      createOrUpdateEnvironment: [
+        "PUT /repos/{owner}/{repo}/environments/{environment_name}"
+      ],
+      createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
+      createOrgRuleset: ["POST /orgs/{org}/rulesets"],
+      createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"],
+      createPagesSite: ["POST /repos/{owner}/{repo}/pages"],
+      createRelease: ["POST /repos/{owner}/{repo}/releases"],
+      createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"],
+      createTagProtection: ["POST /repos/{owner}/{repo}/tags/protection"],
+      createUsingTemplate: [
+        "POST /repos/{template_owner}/{template_repo}/generate"
+      ],
+      createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
+      declineInvitation: [
+        "DELETE /user/repository_invitations/{invitation_id}",
+        {},
+        { renamed: ["repos", "declineInvitationForAuthenticatedUser"] }
+      ],
+      declineInvitationForAuthenticatedUser: [
+        "DELETE /user/repository_invitations/{invitation_id}"
+      ],
+      delete: ["DELETE /repos/{owner}/{repo}"],
+      deleteAccessRestrictions: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"
+      ],
+      deleteAdminBranchProtection: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
+      ],
+      deleteAnEnvironment: [
+        "DELETE /repos/{owner}/{repo}/environments/{environment_name}"
+      ],
+      deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"],
+      deleteBranchProtection: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection"
+      ],
+      deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
+      deleteCommitSignatureProtection: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
+      ],
+      deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
+      deleteDeployment: [
+        "DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"
+      ],
+      deleteDeploymentBranchPolicy: [
+        "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
+      ],
+      deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
+      deleteInvitation: [
+        "DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"
+      ],
+      deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"],
+      deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"],
+      deletePullRequestReviewProtection: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
+      ],
+      deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
+      deleteReleaseAsset: [
+        "DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"
+      ],
+      deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
+      deleteTagProtection: [
+        "DELETE /repos/{owner}/{repo}/tags/protection/{tag_protection_id}"
+      ],
+      deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
+      disableAutomatedSecurityFixes: [
+        "DELETE /repos/{owner}/{repo}/automated-security-fixes"
+      ],
+      disableDeploymentProtectionRule: [
+        "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"
+      ],
+      disablePrivateVulnerabilityReporting: [
+        "DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"
+      ],
+      disableVulnerabilityAlerts: [
+        "DELETE /repos/{owner}/{repo}/vulnerability-alerts"
+      ],
+      downloadArchive: [
+        "GET /repos/{owner}/{repo}/zipball/{ref}",
+        {},
+        { renamed: ["repos", "downloadZipballArchive"] }
+      ],
+      downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"],
+      downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"],
+      enableAutomatedSecurityFixes: [
+        "PUT /repos/{owner}/{repo}/automated-security-fixes"
+      ],
+      enablePrivateVulnerabilityReporting: [
+        "PUT /repos/{owner}/{repo}/private-vulnerability-reporting"
+      ],
+      enableVulnerabilityAlerts: [
+        "PUT /repos/{owner}/{repo}/vulnerability-alerts"
+      ],
+      generateReleaseNotes: [
+        "POST /repos/{owner}/{repo}/releases/generate-notes"
+      ],
+      get: ["GET /repos/{owner}/{repo}"],
+      getAccessRestrictions: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"
+      ],
+      getAdminBranchProtection: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
+      ],
+      getAllDeploymentProtectionRules: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"
+      ],
+      getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"],
+      getAllStatusCheckContexts: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"
+      ],
+      getAllTopics: ["GET /repos/{owner}/{repo}/topics"],
+      getAppsWithAccessToProtectedBranch: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"
+      ],
+      getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"],
+      getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
+      getBranchProtection: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection"
+      ],
+      getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"],
+      getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
+      getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
+      getCollaboratorPermissionLevel: [
+        "GET /repos/{owner}/{repo}/collaborators/{username}/permission"
+      ],
+      getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
+      getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
+      getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
+      getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
+      getCommitSignatureProtection: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
+      ],
+      getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
+      getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
+      getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
+      getCustomDeploymentProtectionRule: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"
+      ],
+      getCustomPropertiesValues: ["GET /repos/{owner}/{repo}/properties/values"],
+      getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
+      getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
+      getDeploymentBranchPolicy: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
+      ],
+      getDeploymentStatus: [
+        "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"
+      ],
+      getEnvironment: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}"
+      ],
+      getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
+      getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
+      getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"],
+      getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"],
+      getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"],
+      getOrgRulesets: ["GET /orgs/{org}/rulesets"],
+      getPages: ["GET /repos/{owner}/{repo}/pages"],
+      getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
+      getPagesDeployment: [
+        "GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"
+      ],
+      getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"],
+      getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
+      getPullRequestReviewProtection: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
+      ],
+      getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
+      getReadme: ["GET /repos/{owner}/{repo}/readme"],
+      getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"],
+      getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
+      getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
+      getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
+      getRepoRuleSuite: [
+        "GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"
+      ],
+      getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"],
+      getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
+      getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"],
+      getStatusChecksProtection: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
+      ],
+      getTeamsWithAccessToProtectedBranch: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"
+      ],
+      getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
+      getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
+      getUsersWithAccessToProtectedBranch: [
+        "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"
+      ],
+      getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
+      getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
+      getWebhookConfigForRepo: [
+        "GET /repos/{owner}/{repo}/hooks/{hook_id}/config"
+      ],
+      getWebhookDelivery: [
+        "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"
+      ],
+      listActivities: ["GET /repos/{owner}/{repo}/activity"],
+      listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"],
+      listBranches: ["GET /repos/{owner}/{repo}/branches"],
+      listBranchesForHeadCommit: [
+        "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"
+      ],
+      listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
+      listCommentsForCommit: [
+        "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"
+      ],
+      listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
+      listCommitStatusesForRef: [
+        "GET /repos/{owner}/{repo}/commits/{ref}/statuses"
+      ],
+      listCommits: ["GET /repos/{owner}/{repo}/commits"],
+      listContributors: ["GET /repos/{owner}/{repo}/contributors"],
+      listCustomDeploymentRuleIntegrations: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"
+      ],
+      listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
+      listDeploymentBranchPolicies: [
+        "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"
+      ],
+      listDeploymentStatuses: [
+        "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"
+      ],
+      listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
+      listForAuthenticatedUser: ["GET /user/repos"],
+      listForOrg: ["GET /orgs/{org}/repos"],
+      listForUser: ["GET /users/{username}/repos"],
+      listForks: ["GET /repos/{owner}/{repo}/forks"],
+      listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
+      listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
+      listLanguages: ["GET /repos/{owner}/{repo}/languages"],
+      listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
+      listPublic: ["GET /repositories"],
+      listPullRequestsAssociatedWithCommit: [
+        "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"
+      ],
+      listReleaseAssets: [
+        "GET /repos/{owner}/{repo}/releases/{release_id}/assets"
+      ],
+      listReleases: ["GET /repos/{owner}/{repo}/releases"],
+      listTagProtection: ["GET /repos/{owner}/{repo}/tags/protection"],
+      listTags: ["GET /repos/{owner}/{repo}/tags"],
+      listTeams: ["GET /repos/{owner}/{repo}/teams"],
+      listWebhookDeliveries: [
+        "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"
+      ],
+      listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
+      merge: ["POST /repos/{owner}/{repo}/merges"],
+      mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"],
+      pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
+      redeliverWebhookDelivery: [
+        "POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"
+      ],
+      removeAppAccessRestrictions: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
+        {},
+        { mapToData: "apps" }
+      ],
+      removeCollaborator: [
+        "DELETE /repos/{owner}/{repo}/collaborators/{username}"
+      ],
+      removeStatusCheckContexts: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
+        {},
+        { mapToData: "contexts" }
+      ],
+      removeStatusCheckProtection: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
+      ],
+      removeTeamAccessRestrictions: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
+        {},
+        { mapToData: "teams" }
+      ],
+      removeUserAccessRestrictions: [
+        "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
+        {},
+        { mapToData: "users" }
+      ],
+      renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"],
+      replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"],
+      requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
+      setAdminBranchProtection: [
+        "POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
+      ],
+      setAppAccessRestrictions: [
+        "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
+        {},
+        { mapToData: "apps" }
+      ],
+      setStatusCheckContexts: [
+        "PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
+        {},
+        { mapToData: "contexts" }
+      ],
+      setTeamAccessRestrictions: [
+        "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
+        {},
+        { mapToData: "teams" }
+      ],
+      setUserAccessRestrictions: [
+        "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
+        {},
+        { mapToData: "users" }
+      ],
+      testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
+      transfer: ["POST /repos/{owner}/{repo}/transfer"],
+      update: ["PATCH /repos/{owner}/{repo}"],
+      updateBranchProtection: [
+        "PUT /repos/{owner}/{repo}/branches/{branch}/protection"
+      ],
+      updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
+      updateDeploymentBranchPolicy: [
+        "PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
+      ],
+      updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
+      updateInvitation: [
+        "PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"
+      ],
+      updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_id}"],
+      updatePullRequestReviewProtection: [
+        "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
+      ],
+      updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
+      updateReleaseAsset: [
+        "PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"
+      ],
+      updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
+      updateStatusCheckPotection: [
+        "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks",
+        {},
+        { renamed: ["repos", "updateStatusCheckProtection"] }
+      ],
+      updateStatusCheckProtection: [
+        "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
+      ],
+      updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
+      updateWebhookConfigForRepo: [
+        "PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"
+      ],
+      uploadReleaseAsset: [
+        "POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}",
+        { baseUrl: "https://uploads.github.com" }
+      ]
+    },
+    search: {
+      code: ["GET /search/code"],
+      commits: ["GET /search/commits"],
+      issuesAndPullRequests: ["GET /search/issues"],
+      labels: ["GET /search/labels"],
+      repos: ["GET /search/repositories"],
+      topics: ["GET /search/topics"],
+      users: ["GET /search/users"]
+    },
+    secretScanning: {
+      getAlert: [
+        "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"
+      ],
+      listAlertsForEnterprise: [
+        "GET /enterprises/{enterprise}/secret-scanning/alerts"
+      ],
+      listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"],
+      listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"],
+      listLocationsForAlert: [
+        "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"
+      ],
+      updateAlert: [
+        "PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"
+      ]
+    },
+    securityAdvisories: {
+      createFork: [
+        "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"
+      ],
+      createPrivateVulnerabilityReport: [
+        "POST /repos/{owner}/{repo}/security-advisories/reports"
+      ],
+      createRepositoryAdvisory: [
+        "POST /repos/{owner}/{repo}/security-advisories"
+      ],
+      createRepositoryAdvisoryCveRequest: [
+        "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"
+      ],
+      getGlobalAdvisory: ["GET /advisories/{ghsa_id}"],
+      getRepositoryAdvisory: [
+        "GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"
+      ],
+      listGlobalAdvisories: ["GET /advisories"],
+      listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"],
+      listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"],
+      updateRepositoryAdvisory: [
+        "PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"
+      ]
+    },
+    teams: {
+      addOrUpdateMembershipForUserInOrg: [
+        "PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"
+      ],
+      addOrUpdateProjectPermissionsInOrg: [
+        "PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}"
+      ],
+      addOrUpdateRepoPermissionsInOrg: [
+        "PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
+      ],
+      checkPermissionsForProjectInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/projects/{project_id}"
+      ],
+      checkPermissionsForRepoInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
+      ],
+      create: ["POST /orgs/{org}/teams"],
+      createDiscussionCommentInOrg: [
+        "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"
+      ],
+      createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
+      deleteDiscussionCommentInOrg: [
+        "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
+      ],
+      deleteDiscussionInOrg: [
+        "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
+      ],
+      deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
+      getByName: ["GET /orgs/{org}/teams/{team_slug}"],
+      getDiscussionCommentInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
+      ],
+      getDiscussionInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
+      ],
+      getMembershipForUserInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/memberships/{username}"
+      ],
+      list: ["GET /orgs/{org}/teams"],
+      listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
+      listDiscussionCommentsInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"
+      ],
+      listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
+      listForAuthenticatedUser: ["GET /user/teams"],
+      listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
+      listPendingInvitationsInOrg: [
+        "GET /orgs/{org}/teams/{team_slug}/invitations"
+      ],
+      listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects"],
+      listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
+      removeMembershipForUserInOrg: [
+        "DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"
+      ],
+      removeProjectInOrg: [
+        "DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"
+      ],
+      removeRepoInOrg: [
+        "DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
+      ],
+      updateDiscussionCommentInOrg: [
+        "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
+      ],
+      updateDiscussionInOrg: [
+        "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
+      ],
+      updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
+    },
+    users: {
+      addEmailForAuthenticated: [
+        "POST /user/emails",
+        {},
+        { renamed: ["users", "addEmailForAuthenticatedUser"] }
+      ],
+      addEmailForAuthenticatedUser: ["POST /user/emails"],
+      addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"],
+      block: ["PUT /user/blocks/{username}"],
+      checkBlocked: ["GET /user/blocks/{username}"],
+      checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
+      checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
+      createGpgKeyForAuthenticated: [
+        "POST /user/gpg_keys",
+        {},
+        { renamed: ["users", "createGpgKeyForAuthenticatedUser"] }
+      ],
+      createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"],
+      createPublicSshKeyForAuthenticated: [
+        "POST /user/keys",
+        {},
+        { renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] }
+      ],
+      createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"],
+      createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"],
+      deleteEmailForAuthenticated: [
+        "DELETE /user/emails",
+        {},
+        { renamed: ["users", "deleteEmailForAuthenticatedUser"] }
+      ],
+      deleteEmailForAuthenticatedUser: ["DELETE /user/emails"],
+      deleteGpgKeyForAuthenticated: [
+        "DELETE /user/gpg_keys/{gpg_key_id}",
+        {},
+        { renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] }
+      ],
+      deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"],
+      deletePublicSshKeyForAuthenticated: [
+        "DELETE /user/keys/{key_id}",
+        {},
+        { renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] }
+      ],
+      deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"],
+      deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"],
+      deleteSshSigningKeyForAuthenticatedUser: [
+        "DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"
+      ],
+      follow: ["PUT /user/following/{username}"],
+      getAuthenticated: ["GET /user"],
+      getByUsername: ["GET /users/{username}"],
+      getContextForUser: ["GET /users/{username}/hovercard"],
+      getGpgKeyForAuthenticated: [
+        "GET /user/gpg_keys/{gpg_key_id}",
+        {},
+        { renamed: ["users", "getGpgKeyForAuthenticatedUser"] }
+      ],
+      getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"],
+      getPublicSshKeyForAuthenticated: [
+        "GET /user/keys/{key_id}",
+        {},
+        { renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] }
+      ],
+      getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"],
+      getSshSigningKeyForAuthenticatedUser: [
+        "GET /user/ssh_signing_keys/{ssh_signing_key_id}"
+      ],
+      list: ["GET /users"],
+      listBlockedByAuthenticated: [
+        "GET /user/blocks",
+        {},
+        { renamed: ["users", "listBlockedByAuthenticatedUser"] }
+      ],
+      listBlockedByAuthenticatedUser: ["GET /user/blocks"],
+      listEmailsForAuthenticated: [
+        "GET /user/emails",
+        {},
+        { renamed: ["users", "listEmailsForAuthenticatedUser"] }
+      ],
+      listEmailsForAuthenticatedUser: ["GET /user/emails"],
+      listFollowedByAuthenticated: [
+        "GET /user/following",
+        {},
+        { renamed: ["users", "listFollowedByAuthenticatedUser"] }
+      ],
+      listFollowedByAuthenticatedUser: ["GET /user/following"],
+      listFollowersForAuthenticatedUser: ["GET /user/followers"],
+      listFollowersForUser: ["GET /users/{username}/followers"],
+      listFollowingForUser: ["GET /users/{username}/following"],
+      listGpgKeysForAuthenticated: [
+        "GET /user/gpg_keys",
+        {},
+        { renamed: ["users", "listGpgKeysForAuthenticatedUser"] }
+      ],
+      listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"],
+      listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
+      listPublicEmailsForAuthenticated: [
+        "GET /user/public_emails",
+        {},
+        { renamed: ["users", "listPublicEmailsForAuthenticatedUser"] }
+      ],
+      listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"],
+      listPublicKeysForUser: ["GET /users/{username}/keys"],
+      listPublicSshKeysForAuthenticated: [
+        "GET /user/keys",
+        {},
+        { renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] }
+      ],
+      listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"],
+      listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"],
+      listSocialAccountsForUser: ["GET /users/{username}/social_accounts"],
+      listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"],
+      listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"],
+      setPrimaryEmailVisibilityForAuthenticated: [
+        "PATCH /user/email/visibility",
+        {},
+        { renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] }
+      ],
+      setPrimaryEmailVisibilityForAuthenticatedUser: [
+        "PATCH /user/email/visibility"
+      ],
+      unblock: ["DELETE /user/blocks/{username}"],
+      unfollow: ["DELETE /user/following/{username}"],
+      updateAuthenticated: ["PATCH /user"]
+    }
+  };
+  var endpoints_default = Endpoints;
+  var endpointMethodsMap = /* @__PURE__ */ new Map();
+  for (const [scope, endpoints] of Object.entries(endpoints_default)) {
+    for (const [methodName, endpoint2] of Object.entries(endpoints)) {
+      const [route, defaults, decorations] = endpoint2;
+      const [method, url] = route.split(/ /);
+      const endpointDefaults = Object.assign(
+        {
+          method,
+          url
+        },
+        defaults
+      );
+      if (!endpointMethodsMap.has(scope)) {
+        endpointMethodsMap.set(scope, /* @__PURE__ */ new Map());
+      }
+      endpointMethodsMap.get(scope).set(methodName, {
+        scope,
+        methodName,
+        endpointDefaults,
+        decorations
+      });
+    }
+  }
+  var handler = {
+    has({ scope }, methodName) {
+      return endpointMethodsMap.get(scope).has(methodName);
+    },
+    getOwnPropertyDescriptor(target, methodName) {
+      return {
+        value: this.get(target, methodName),
+        // ensures method is in the cache
+        configurable: true,
+        writable: true,
+        enumerable: true
+      };
+    },
+    defineProperty(target, methodName, descriptor) {
+      Object.defineProperty(target.cache, methodName, descriptor);
+      return true;
+    },
+    deleteProperty(target, methodName) {
+      delete target.cache[methodName];
+      return true;
+    },
+    ownKeys({ scope }) {
+      return [...endpointMethodsMap.get(scope).keys()];
+    },
+    set(target, methodName, value) {
+      return target.cache[methodName] = value;
+    },
+    get({ octokit: octokit2, scope, cache }, methodName) {
+      if (cache[methodName]) {
+        return cache[methodName];
+      }
+      const method = endpointMethodsMap.get(scope).get(methodName);
+      if (!method) {
+        return void 0;
+      }
+      const { endpointDefaults, decorations } = method;
+      if (decorations) {
+        cache[methodName] = decorate(
+          octokit2,
+          scope,
+          methodName,
+          endpointDefaults,
+          decorations
+        );
+      } else {
+        cache[methodName] = octokit2.request.defaults(endpointDefaults);
+      }
+      return cache[methodName];
+    }
+  };
+  function endpointsToMethods(octokit2) {
+    const newMethods = {};
+    for (const scope of endpointMethodsMap.keys()) {
+      newMethods[scope] = new Proxy({ octokit: octokit2, scope, cache: {} }, handler);
+    }
+    return newMethods;
+  }
+  function decorate(octokit2, scope, methodName, defaults, decorations) {
+    const requestWithDefaults = octokit2.request.defaults(defaults);
+    function withDecorations(...args) {
+      let options = requestWithDefaults.endpoint.merge(...args);
+      if (decorations.mapToData) {
+        options = Object.assign({}, options, {
+          data: options[decorations.mapToData],
+          [decorations.mapToData]: void 0
+        });
+        return requestWithDefaults(options);
+      }
+      if (decorations.renamed) {
+        const [newScope, newMethodName] = decorations.renamed;
+        octokit2.log.warn(
+          `octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`
+        );
+      }
+      if (decorations.deprecated) {
+        octokit2.log.warn(decorations.deprecated);
+      }
+      if (decorations.renamedParameters) {
+        const options2 = requestWithDefaults.endpoint.merge(...args);
+        for (const [name, alias] of Object.entries(
+          decorations.renamedParameters
+        )) {
+          if (name in options2) {
+            octokit2.log.warn(
+              `"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`
+            );
+            if (!(alias in options2)) {
+              options2[alias] = options2[name];
+            }
+            delete options2[name];
+          }
+        }
+        return requestWithDefaults(options2);
+      }
+      return requestWithDefaults(...args);
+    }
+    return Object.assign(withDecorations, requestWithDefaults);
+  }
+  function restEndpointMethods(octokit2) {
+    const api = endpointsToMethods(octokit2);
+    return {
+      rest: api
+    };
+  }
+  restEndpointMethods.VERSION = VERSION7;
+  function legacyRestEndpointMethods(octokit2) {
+    const api = endpointsToMethods(octokit2);
+    return {
+      ...api,
+      rest: api
+    };
+  }
+  legacyRestEndpointMethods.VERSION = VERSION7;
+
+  // node_modules/@octokit/rest/dist-src/version.js
+  var VERSION8 = "21.0.1";
+
+  // node_modules/@octokit/rest/dist-src/index.js
+  var Octokit2 = Octokit.plugin(requestLog, legacyRestEndpointMethods, paginateRest).defaults(
+    {
+      userAgent: `octokit-rest.js/${VERSION8}`
+    }
+  );
+
+  // root.ts
+  var root_default = process.cwd();
+
+  // bin/branches.ts
+  process.on("unhandledRejection", (up) => {
+    throw up;
+  });
+  var octokit = new Octokit2({ auth: `token ${process.env.GITHUB_TOKEN}` });
+  var pkg = __require(path.join(root_default, "package.json"));
+  var [, owner, repo] = pkg.repository.url.match(/:\/\/github.com\/([^/]+)\/([^.]+)\.git$/);
+  async function main() {
+    const branches = await octokit.repos.listBranches({ owner, repo });
+    for (const branch of branches.data) {
+      if (/^[0-9]+$/.exec(branch.name)) {
+        const issue = await octokit.issues.get({ owner, repo, issue_number: parseInt(branch.name) });
+        if (issue.data.state !== "open") console.log(branch.name, issue.data.state);
+      } else if (!["master", "main", "gh-pages"].includes(branch.name)) {
+        console.log(branch.name);
+      }
     }
-}
-main().catch(err => console.log(err));
+  }
+  main().catch((err) => console.log(err));
+})();