@codacy/analysis-runner 0.1.0

package/dist/index.js

@@ -0,0 +1,4888 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  analyze: () => analyze,
+  applyCodacyYamlExcludes: () => applyCodacyYamlExcludes,
+  buildToolConfig: () => buildToolConfig,
+  clearAdapters: () => clearAdapters,
+  configureApiToken: () => configureApiToken,
+  createCodacyConfig: () => createCodacyConfig,
+  createLogger: () => createLogger,
+  detectLanguages: () => detectLanguages,
+  formatOutput: () => formatOutput,
+  formatTextSummary: () => formatTextSummary,
+  getRegisteredAdapters: () => getRegisteredAdapters,
+  initContainerConfig: () => initContainerConfig,
+  initDefaultConfig: () => initDefaultConfig,
+  initLocalConfig: () => initLocalConfig,
+  initRemoteConfig: () => initRemoteConfig,
+  readCodacyConfig: () => readCodacyConfig,
+  readCodacyYaml: () => readCodacyYaml,
+  registerAdapter: () => registerAdapter,
+  resolveEngineToAdapter: () => resolveEngineToAdapter,
+  rotateLogFiles: () => rotateLogFiles,
+  validateApiToken: () => validateApiToken,
+  writeCodacyConfig: () => writeCodacyConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/analyze.ts
+var import_os = __toESM(require("os"));
+var import_path3 = __toESM(require("path"));
+
+// src/registry.ts
+var adapters = /* @__PURE__ */ new Map();
+function registerAdapter(adapter) {
+  adapters.set(adapter.id, adapter);
+}
+function resolveAdapter(input) {
+  const exact = adapters.get(input);
+  if (exact) return exact;
+  const needle = input.toLowerCase();
+  const matches = Array.from(adapters.values()).filter((a) => {
+    return a.id.toLowerCase().includes(needle) || a.displayName.toLowerCase().includes(needle);
+  });
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function getRegisteredAdapters(toolIds) {
+  if (toolIds && toolIds.length > 0) {
+    return toolIds.map((id) => resolveAdapter(id)).filter((a) => a !== void 0);
+  }
+  return Array.from(adapters.values());
+}
+function clearAdapters() {
+  adapters.clear();
+}
+
+// src/config.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var CODACY_DIR = ".codacy";
+var CONFIG_FILE = "codacy.config.json";
+async function readCodacyConfig(repositoryRoot) {
+  const configPath = import_path.default.join(repositoryRoot, CODACY_DIR, CONFIG_FILE);
+  try {
+    const raw = await import_promises.default.readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCodacyConfig(repositoryRoot, config) {
+  const codacyDir = import_path.default.join(repositoryRoot, CODACY_DIR);
+  await import_promises.default.mkdir(codacyDir, { recursive: true });
+  await ensureGitignore(codacyDir);
+  const configPath = import_path.default.join(codacyDir, CONFIG_FILE);
+  await import_promises.default.writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  return configPath;
+}
+async function ensureGitignore(codacyDir) {
+  const gitignorePath = import_path.default.join(codacyDir, ".gitignore");
+  try {
+    const content = await import_promises.default.readFile(gitignorePath, "utf-8");
+    if (!content.includes("generated/")) {
+      await import_promises.default.writeFile(gitignorePath, content.trimEnd() + "\ngenerated/\n");
+    }
+  } catch {
+    await import_promises.default.writeFile(gitignorePath, "generated/\n");
+  }
+}
+function buildToolConfig(codacyConfig, adapter, configCheck) {
+  const existing = getToolConfig(codacyConfig, adapter.id);
+  const config = existing ? { ...existing } : { toolId: adapter.id, patterns: [] };
+  if (configCheck.found && configCheck.path) {
+    if (!existing || existing.useLocalConfigurationFile !== false) {
+      config.localConfigurationFile = configCheck.path;
+      config.useLocalConfigurationFile = true;
+    }
+  }
+  return config;
+}
+function getToolConfig(codacyConfig, toolId) {
+  if (!codacyConfig) return void 0;
+  return codacyConfig.tools.find((t) => t.toolId === toolId);
+}
+function createCodacyConfig(params = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const config = {
+    version: 1,
+    metadata: {
+      source: params.source ?? "local",
+      provider: params.provider ?? null,
+      organization: params.organization ?? null,
+      repositoryId: params.repositoryId ?? null,
+      repositoryName: params.repositoryName ?? null,
+      createdAt: now,
+      updatedAt: now,
+      languages: params.languages ?? []
+    },
+    tools: params.tools ?? [],
+    exclude: []
+  };
+  if (params.includeFiles && params.includeFiles.length > 0) {
+    config.includeFiles = params.includeFiles;
+  }
+  return config;
+}
+
+// src/files.ts
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"));
+var import_minimatch = require("minimatch");
+function listRepoFiles(repositoryRoot) {
+  try {
+    const tracked = (0, import_child_process.execSync)("git ls-files", {
+      cwd: repositoryRoot,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    }).trim();
+    const untracked = (0, import_child_process.execSync)("git ls-files --others --exclude-standard", {
+      cwd: repositoryRoot,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    }).trim();
+    const files = /* @__PURE__ */ new Set();
+    for (const f of tracked.split("\n")) {
+      if (f) files.add(f);
+    }
+    for (const f of untracked.split("\n")) {
+      if (f) files.add(f);
+    }
+    return Array.from(files).sort();
+  } catch {
+    return [];
+  }
+}
+function applyExclusions(files, globalExclude, toolExclude) {
+  const allExclusions = [...globalExclude, ...toolExclude];
+  if (allExclusions.length === 0) return files;
+  return files.filter((file) => {
+    const basename = import_path2.default.basename(file);
+    return !allExclusions.some((pattern) => {
+      if ((0, import_minimatch.minimatch)(file, pattern, { dot: true })) return true;
+      if (!pattern.includes("/") && (0, import_minimatch.minimatch)(basename, pattern, { dot: true })) return true;
+      return false;
+    });
+  });
+}
+function routeFilesToTool(files, adapter, toolConfig) {
+  const patterns = [...adapter.filePatterns];
+  if (toolConfig?.extraFilePatterns) {
+    patterns.push(...toolConfig.extraFilePatterns);
+  }
+  if (patterns.includes("*")) return files;
+  return files.filter((file) => {
+    const basename = import_path2.default.basename(file);
+    return patterns.some(
+      (pattern) => (0, import_minimatch.minimatch)(basename, pattern, { dot: true }) || (0, import_minimatch.minimatch)(file, pattern, { dot: true })
+    );
+  });
+}
+function filterByTargetFiles(allFiles, targetPatterns) {
+  if (targetPatterns.length === 0) return allFiles;
+  const normalized = targetPatterns.map((p) => p.replace(/^\.\//, ""));
+  return allFiles.filter(
+    (f) => normalized.some(
+      (pattern) => (
+        // Exact match (fast path)
+        f === pattern || // Glob match
+        (0, import_minimatch.minimatch)(f, pattern, { dot: true, matchBase: false }) || // Directory prefix (e.g. "src/subdir/" matches all files under it)
+        pattern.endsWith("/") && f.startsWith(pattern)
+      )
+    )
+  );
+}
+
+// src/executor.ts
+async function runTool(adapter, ctx, codacyToolConfig, timeoutMs) {
+  const startTime = Date.now();
+  ctx.logger.debug("runTool started", { toolId: adapter.id, fileCount: ctx.targetFiles.length, timeoutMs });
+  try {
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      setTimeout(() => reject(new Error(`TIMEOUT: Tool ${adapter.id} exceeded ${timeoutMs}ms`)), timeoutMs);
+    });
+    const result = await Promise.race([
+      adapter.analyze(ctx, codacyToolConfig),
+      timeoutPromise
+    ]);
+    ctx.logger.debug("runTool completed", { toolId: adapter.id, issueCount: result.summary.issueCount, durationMs: result.summary.durationMs });
+    return result;
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    const isTimeout = err instanceof Error && err.message.includes("TIMEOUT");
+    if (isTimeout) {
+      ctx.logger.error("Tool timed out", { toolId: adapter.id, timeoutMs, elapsedMs: durationMs });
+    } else {
+      ctx.logger.error("Tool execution failed", { toolId: adapter.id, error: err instanceof Error ? err.message : String(err), durationMs });
+    }
+    const now = /* @__PURE__ */ new Date();
+    return {
+      metadata: {
+        startedAt: new Date(now.getTime() - durationMs).toISOString(),
+        completedAt: now.toISOString(),
+        durationMs
+      },
+      issues: [],
+      errors: [
+        {
+          toolId: adapter.id,
+          phase: "toolInvoke",
+          kind: isTimeout ? "Timeout" : "InvocationError",
+          message: isTimeout ? `Tool ${adapter.id} exceeded timeout of ${timeoutMs}ms` : `Tool ${adapter.id} failed: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      ],
+      summary: {
+        toolId: adapter.id,
+        status: "failed",
+        issueCount: 0,
+        errorCount: 1,
+        durationMs,
+        filesAnalyzed: ctx.targetFiles.length
+      }
+    };
+  }
+}
+async function runToolsSequential(tools, timeoutMs, callbacks) {
+  const results = [];
+  for (const { adapter, ctx, codacyToolConfig } of tools) {
+    callbacks?.onToolStart?.(adapter.id, adapter.displayName);
+    const result = await runTool(adapter, ctx, codacyToolConfig, timeoutMs);
+    callbacks?.onToolComplete?.(adapter.id, adapter.displayName, result.summary.issueCount, result.summary.durationMs);
+    results.push(result);
+  }
+  return results;
+}
+async function runToolsParallel(tools, timeoutMs, concurrency, callbacks) {
+  const results = new Array(tools.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < tools.length) {
+      const index = nextIndex++;
+      const { adapter, ctx, codacyToolConfig } = tools[index];
+      callbacks?.onToolStart?.(adapter.id, adapter.displayName);
+      results[index] = await runTool(adapter, ctx, codacyToolConfig, timeoutMs);
+      callbacks?.onToolComplete?.(adapter.id, adapter.displayName, results[index].summary.issueCount, results[index].summary.durationMs);
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, tools.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// src/analyze.ts
+var nullLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+async function analyze(options) {
+  const startedAt = /* @__PURE__ */ new Date();
+  const mode = options.mode || "standard";
+  const toolTimeout = options.toolTimeout || 3e5;
+  const parallelTools = options.parallelTools || 1;
+  const logger = options.logger ?? nullLogger;
+  const adapters2 = getRegisteredAdapters(options.tools);
+  logger.info("Pipeline started", { mode, toolCount: adapters2.length, parallelTools, toolTimeout });
+  const globalDir = import_path3.default.join(import_os.default.homedir(), ".codacy");
+  const baseCtx = {
+    repositoryRoot: options.repositoryRoot,
+    globalDir,
+    platform: { os: import_os.default.platform(), arch: import_os.default.arch() },
+    logger,
+    runner: "local"
+  };
+  const ready = [];
+  const unavailable = [];
+  const availabilityTimeout = 6e4;
+  for (const adapter of adapters2) {
+    const ctx = makeToolContext(baseCtx, adapter, []);
+    const checkStart = Date.now();
+    logger.debug("Checking availability", { toolId: adapter.id });
+    try {
+      const availability = await Promise.race([
+        adapter.checkAvailability(ctx),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`checkAvailability timed out after ${availabilityTimeout}ms`)), availabilityTimeout)
+        )
+      ]);
+      if (availability.available) {
+        logger.debug("Tool available", { toolId: adapter.id, version: availability.version, installation: availability.installation, durationMs: Date.now() - checkStart });
+        ready.push({
+          toolId: adapter.id,
+          displayName: adapter.displayName,
+          version: availability.version ?? adapter.preferredVersion,
+          installation: availability.installation ?? "global",
+          runner: "local"
+        });
+      } else {
+        logger.warn("Tool unavailable", { toolId: adapter.id, reason: availability.reason, durationMs: Date.now() - checkStart });
+        unavailable.push({
+          toolId: adapter.id,
+          displayName: adapter.displayName,
+          reason: availability.reason || "Tool is not available",
+          ...availability.installHint ? { remediation: availability.installHint } : {}
+        });
+      }
+    } catch (err) {
+      logger.warn("Availability check failed", { toolId: adapter.id, error: err instanceof Error ? err.message : String(err), durationMs: Date.now() - checkStart });
+      unavailable.push({
+        toolId: adapter.id,
+        displayName: adapter.displayName,
+        reason: `Availability check failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  const capability = {
+    ready,
+    unavailable,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const codacyConfig = await readCodacyConfig(options.repositoryRoot);
+  if (codacyConfig) {
+    const readyBefore = capability.ready.length;
+    const configuredIds = new Set(codacyConfig.tools.map((t) => t.toolId));
+    capability.ready = capability.ready.filter((t) => configuredIds.has(t.toolId));
+    capability.unavailable = capability.unavailable.filter((t) => configuredIds.has(t.toolId));
+    logger.debug("Filtered by config", { readyBefore, readyAfter: capability.ready.length, configuredToolCount: configuredIds.size });
+  } else {
+    logger.debug("No codacy config found, running all available tools");
+  }
+  if (mode === "auto-install" && capability.unavailable.length > 0) {
+    const installErrors = [];
+    for (let i = capability.unavailable.length - 1; i >= 0; i--) {
+      const status = capability.unavailable[i];
+      const adapter = adapters2.find((a) => a.id === status.toolId);
+      if (!adapter) continue;
+      const ctx = makeToolContext(baseCtx, adapter, []);
+      logger.info(`${adapter.displayName} is missing, attempting install...`);
+      try {
+        logger.info(`Downloading ${adapter.displayName}...`);
+        const installResult = await adapter.install(ctx);
+        if (installResult.success) {
+          logger.info(`Checking ${adapter.displayName} installation...`);
+          const recheck = await adapter.checkAvailability(ctx);
+          if (recheck.available) {
+            logger.info(`${adapter.displayName} is now available`);
+            capability.ready.push({
+              toolId: adapter.id,
+              displayName: adapter.displayName,
+              version: recheck.version ?? installResult.installedVersion ?? adapter.preferredVersion,
+              installation: recheck.installation ?? "codacy",
+              runner: "local"
+            });
+            capability.unavailable.splice(i, 1);
+          } else {
+            logger.error(`${adapter.displayName} post-install check failed: ${recheck.reason ?? "unknown"}`);
+            installErrors.push({
+              toolId: adapter.id,
+              phase: "toolInstall",
+              kind: "PostInstallCheckFailed",
+              message: `Installed ${adapter.id} but availability check still fails: ${recheck.reason ?? "unknown"}`,
+              level: "error"
+            });
+          }
+        } else if (installResult.error?.kind === "NotSupported") {
+          logger.info(`${adapter.displayName} does not support automated install, skipping.`);
+          capability.unavailable.splice(i, 1);
+        } else {
+          const errMsg = installResult.error?.message ?? `Failed to install ${adapter.id}`;
+          logger.error(`${adapter.displayName} install failed: ${errMsg}`);
+          installErrors.push(
+            installResult.error ?? {
+              toolId: adapter.id,
+              phase: "toolInstall",
+              kind: "InstallFailed",
+              message: errMsg,
+              level: "error"
+            }
+          );
+        }
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        logger.error(`${adapter.displayName} install failed: ${errMsg}`);
+        installErrors.push({
+          toolId: adapter.id,
+          phase: "toolInstall",
+          kind: "InstallError",
+          message: `Install failed for ${adapter.id}: ${errMsg}`,
+          level: "error"
+        });
+      }
+    }
+    if (installErrors.length > 0) {
+      return buildResult(startedAt, options.repositoryRoot, mode, capability, [], installErrors, []);
+    }
+  }
+  if (mode === "inspect") {
+    for (const tool of capability.ready) {
+      const adapter = adapters2.find((a) => a.id === tool.toolId);
+      if (!adapter) continue;
+      const ctx = makeToolContext(baseCtx, adapter, []);
+      const availability = await adapter.checkAvailability(ctx).catch(() => null);
+      if (availability?.dependencies) {
+        tool.dependencies = availability.dependencies.filter((d) => d.available && d.version).map((d) => ({
+          name: d.name,
+          version: d.version,
+          installation: d.installation ?? "global"
+        }));
+      }
+      try {
+        const configCheck = await adapter.checkLocalConfigurationFile(ctx);
+        const toolCfg = buildToolConfig(codacyConfig, adapter, configCheck);
+        if (configCheck.found && toolCfg.useLocalConfigurationFile) {
+          tool.configSource = "local";
+          tool.configPath = configCheck.path;
+        } else {
+          tool.configSource = "codacy";
+        }
+      } catch {
+        tool.configSource = "codacy";
+      }
+    }
+    return buildResult(startedAt, options.repositoryRoot, mode, capability, [], [], []);
+  }
+  if (mode === "strict" && capability.unavailable.length > 0) {
+    const missingTools = capability.unavailable.map((u) => u.toolId).join(", ");
+    return buildResult(startedAt, options.repositoryRoot, mode, capability, [], [
+      {
+        toolId: "runner",
+        phase: "requirementCheck",
+        kind: "UnavailableTools",
+        message: `Strict mode: the following tools are unavailable: ${missingTools}`,
+        level: "error"
+      }
+    ], []);
+  }
+  const globalExclude = codacyConfig?.exclude || [];
+  let allFiles = listRepoFiles(options.repositoryRoot);
+  logger.debug("File discovery", { totalFiles: allFiles.length });
+  if (options.files && options.files.length > 0) {
+    allFiles = filterByTargetFiles(allFiles, options.files);
+    logger.debug("Filtered by target files", { afterFilter: allFiles.length });
+  }
+  const readyAdapters = adapters2.filter((a) => capability.ready.some((r) => r.toolId === a.id));
+  const toolRuns = [];
+  for (const adapter of readyAdapters) {
+    const toolConfig = getToolConfig(codacyConfig, adapter.id);
+    if (codacyConfig && !toolConfig) continue;
+    const toolExclude = toolConfig?.exclude || [];
+    const filesAfterExclusion = applyExclusions(allFiles, globalExclude, toolExclude);
+    const toolFiles = routeFilesToTool(filesAfterExclusion, adapter, toolConfig);
+    const readyEntryForFiles = capability.ready.find((r) => r.toolId === adapter.id);
+    if (readyEntryForFiles) {
+      readyEntryForFiles.filesRouted = toolFiles.length;
+    }
+    if (toolFiles.length === 0) {
+      logger.debug("No files routed, skipping", { toolId: adapter.id });
+      continue;
+    }
+    logger.debug("Files routed to tool", { toolId: adapter.id, fileCount: toolFiles.length });
+    const ctx = makeToolContext(baseCtx, adapter, toolFiles);
+    const configCheck = await adapter.checkLocalConfigurationFile(ctx);
+    const codacyToolConfig = buildToolConfig(codacyConfig, adapter, configCheck);
+    logger.debug("Tool config resolved", { toolId: adapter.id, configSource: codacyToolConfig.useLocalConfigurationFile ? "local" : "codacy", patternCount: codacyToolConfig.patterns?.length ?? 0 });
+    const readyEntry = capability.ready.find((r) => r.toolId === adapter.id);
+    if (readyEntry) {
+      if (configCheck.found && codacyToolConfig.useLocalConfigurationFile) {
+        readyEntry.configSource = "local";
+        readyEntry.configPath = configCheck.path;
+      } else {
+        readyEntry.configSource = "codacy";
+      }
+    }
+    toolRuns.push({ adapter, ctx, codacyToolConfig });
+  }
+  logger.info("Starting tool execution", { toolCount: toolRuns.length, parallel: parallelTools > 1, parallelTools });
+  const callbacks = {
+    onToolStart: options.onToolStart,
+    onToolComplete: options.onToolComplete
+  };
+  let results;
+  if (parallelTools > 1 && toolRuns.length > 1) {
+    results = await runToolsParallel(toolRuns, toolTimeout, parallelTools, callbacks);
+  } else {
+    results = await runToolsSequential(toolRuns, toolTimeout, callbacks);
+  }
+  const allIssues = normalizeIssues(results.flatMap((r) => r.issues));
+  const allErrors = results.flatMap((r) => r.errors);
+  const allSummaries = results.map((r) => r.summary);
+  logger.info("Pipeline complete", { totalIssues: allIssues.length, totalErrors: allErrors.length, durationMs: Date.now() - startedAt.getTime() });
+  return buildResult(startedAt, options.repositoryRoot, mode, capability, allIssues, allErrors, allSummaries);
+}
+function makeToolContext(base, adapter, targetFiles) {
+  return {
+    ...base,
+    targetFiles,
+    toolInstallDir: import_path3.default.join(base.globalDir, "tools", adapter.id),
+    generatedConfigDir: import_path3.default.join(base.repositoryRoot, ".codacy", "generated", adapter.id)
+  };
+}
+function normalizeIssues(issues) {
+  return issues.map((issue) => {
+    if (issue.endLine !== void 0 && issue.endLine === issue.line) {
+      const { endLine: _, ...rest } = issue;
+      return rest;
+    }
+    return issue;
+  });
+}
+function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors, toolResults) {
+  const completedAt = /* @__PURE__ */ new Date();
+  return {
+    metadata: {
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs: completedAt.getTime() - startedAt.getTime(),
+      repositoryRoot,
+      executionMode: mode
+    },
+    capability,
+    issues,
+    errors,
+    toolResults
+  };
+}
+
+// src/format.ts
+var import_path4 = __toESM(require("path"));
+var import_ansis = __toESM(require("ansis"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+function formatOutput(result, format) {
+  switch (format) {
+    case "json":
+      return formatJson(result);
+    case "sarif":
+      return formatSarif(result);
+    case "container":
+      return formatContainer(result);
+    case "text":
+      return formatText(result);
+    default:
+      return formatJson(result);
+  }
+}
+function formatJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+function formatSarif(result) {
+  const issuesByTool = /* @__PURE__ */ new Map();
+  for (const issue of result.issues) {
+    const existing = issuesByTool.get(issue.toolId) || [];
+    existing.push(issue);
+    issuesByTool.set(issue.toolId, existing);
+  }
+  const runs = [];
+  for (const [toolId, issues] of issuesByTool) {
+    const toolResult = result.toolResults.find((t) => t.toolId === toolId);
+    const ruleMap = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      if (!ruleMap.has(issue.patternId)) {
+        ruleMap.set(issue.patternId, {
+          id: issue.patternId,
+          shortDescription: issue.message,
+          severity: mapSeverityToSarif(issue.severity)
+        });
+      }
+    }
+    const rules = Array.from(ruleMap.values()).map((rule) => ({
+      id: rule.id,
+      shortDescription: { text: rule.shortDescription },
+      defaultConfiguration: { level: rule.severity }
+    }));
+    const ruleIndex = /* @__PURE__ */ new Map();
+    rules.forEach((r, i) => ruleIndex.set(r.id, i));
+    const results = issues.map((issue) => ({
+      ruleId: issue.patternId,
+      ruleIndex: ruleIndex.get(issue.patternId) ?? 0,
+      level: mapSeverityToSarif(issue.severity),
+      message: { text: issue.message },
+      locations: [
+        {
+          physicalLocation: {
+            artifactLocation: { uri: issue.filePath, uriBaseId: "%SRCROOT%" },
+            region: {
+              startLine: issue.line,
+              startColumn: issue.column,
+              ...issue.endLine ? { endLine: issue.endLine } : {},
+              ...issue.endColumn ? { endColumn: issue.endColumn } : {}
+            }
+          }
+        }
+      ]
+    }));
+    runs.push({
+      tool: {
+        driver: {
+          name: toolId,
+          version: toolResult?.toolId ? "0.0.1" : "0.0.1",
+          rules
+        }
+      },
+      results
+    });
+  }
+  if (runs.length === 0) {
+    runs.push({
+      tool: {
+        driver: {
+          name: "codacy-analysis",
+          version: "0.0.1",
+          rules: []
+        }
+      },
+      results: []
+    });
+  }
+  const sarif = {
+    $schema: "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs
+  };
+  return JSON.stringify(sarif, null, 2);
+}
+function mapSeverityToSarif(severity) {
+  switch (severity) {
+    case "Error":
+      return "error";
+    case "High":
+    case "Warning":
+      return "warning";
+    case "Info":
+      return "note";
+    default:
+      return "warning";
+  }
+}
+function formatContainer(result) {
+  return result.issues.map(
+    (issue) => JSON.stringify({
+      filename: issue.filePath,
+      patternId: issue.patternId,
+      line: issue.line,
+      message: issue.message,
+      suggestion: issue.suggestion
+    })
+  ).join("\n");
+}
+function formatText(result) {
+  const lines = [];
+  const isInspect = result.metadata.executionMode === "inspect";
+  if (result.issues.length > 0) {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const issue of result.issues) {
+      const existing = byFile.get(issue.filePath) || [];
+      existing.push(issue);
+      byFile.set(issue.filePath, existing);
+    }
+    for (const [filePath, issues] of byFile) {
+      lines.push("");
+      lines.push(import_ansis.default.bold.white(filePath));
+      for (const issue of issues) {
+        if (issue.multilineContent && issue.multilineContent.length > 1) {
+          formatMultilineIssue(lines, issue);
+        } else {
+          const truncated = truncateLine(issue.lineContent, MAX_LINE_LENGTH);
+          const endCol = issue.endLine === void 0 ? issue.endColumn : void 0;
+          const clampedEndCol = endCol !== void 0 ? Math.min(endCol, truncated.length + 1) : void 0;
+          const lineContent = highlightSpan(truncated, issue.column, clampedEndCol);
+          lines.push(`  ${import_ansis.default.gray(String(issue.line))} | ${lineContent}`);
+        }
+        const sev = colorSeverity(issue.severity);
+        lines.push(`   \u21B3 ${sev} | ${issue.category} | ${import_ansis.default.dim(issue.patternId)}`);
+        const message = issue.message.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+        lines.push(`     ${message}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const error of result.errors) {
+      const prefix = `[${error.toolId}/${error.phase}]`;
+      const location = error.filePath ? ` ${error.filePath}:` : "";
+      lines.push(import_ansis.default.red(`  ${prefix}${location} ${error.message}`));
+    }
+    lines.push("");
+  }
+  lines.push(formatTextSummary(result, isInspect));
+  return lines.join("\n");
+}
+function formatTextSummary(result, isInspect) {
+  const lines = [];
+  const inspect = isInspect ?? result.metadata.executionMode === "inspect";
+  const totalIssues = result.issues.length;
+  const totalErrors = result.errors.length;
+  const toolCount = result.toolResults.length;
+  const duration = result.metadata.durationMs;
+  if (inspect) {
+    const totalTools = result.capability.ready.length + result.capability.unavailable.length;
+    lines.push(
+      import_ansis.default.bold(`Inspection complete: ${totalTools} tool${totalTools !== 1 ? "s" : ""} found`)
+    );
+  } else {
+    const headerLine = `Analysis complete: ${totalIssues} issue${totalIssues !== 1 ? "s" : ""} found`;
+    lines.push(totalIssues > 0 ? import_ansis.default.bold.red(headerLine) : import_ansis.default.bold(headerLine));
+    lines.push(`${toolCount} tool${toolCount !== 1 ? "s" : ""} ran in ${duration}ms`);
+  }
+  if (totalErrors > 0) {
+    lines.push(import_ansis.default.red(`${totalErrors} error${totalErrors !== 1 ? "s" : ""} occurred`));
+  }
+  lines.push("");
+  const sortByName = (a, b) => (a.displayName ?? a.toolId).localeCompare(b.displayName ?? b.toolId);
+  const readyTools = [...result.capability.ready].sort(sortByName);
+  const unavailableTools = [...result.capability.unavailable].sort(sortByName);
+  const hasTools = readyTools.length > 0 || unavailableTools.length > 0;
+  if (hasTools) {
+    if (inspect) {
+      const table = new import_cli_table3.default({
+        head: ["Tool", "Version", "Install", "Configuration", "Files", "Prerequisites"],
+        style: { head: ["bold", "white"] }
+      });
+      for (const tool of readyTools) {
+        let prereqCell;
+        if (tool.dependencies && tool.dependencies.length > 0) {
+          prereqCell = tool.dependencies.map((d) => `${d.name} ${d.version} \u2713`).join(", ");
+        } else {
+          prereqCell = "-";
+        }
+        const filesCell = formatFilesCell(tool.filesRouted);
+        table.push([
+          import_ansis.default.cyan(tool.displayName ?? tool.toolId),
+          tool.version,
+          tool.installation,
+          formatConfigCell(tool, result.metadata.repositoryRoot),
+          filesCell,
+          prereqCell
+        ]);
+      }
+      for (const tool of unavailableTools) {
+        table.push([import_ansis.default.dim.red(tool.displayName ?? tool.toolId), "-", "-", "-", "-", tool.reason]);
+      }
+      lines.push(table.toString());
+    } else {
+      const table = new import_cli_table3.default({
+        head: ["Tool", "Version", "Install", "Configuration", "Files", "Issues", "Duration"],
+        style: { head: ["bold", "white"] }
+      });
+      for (const tool of readyTools) {
+        const summary = result.toolResults.find((t) => t.toolId === tool.toolId);
+        const issueCount = summary?.issueCount ?? 0;
+        const durationMs = summary?.durationMs ?? 0;
+        const filesCell = formatFilesCell(tool.filesRouted);
+        table.push([
+          import_ansis.default.cyan(tool.displayName ?? tool.toolId),
+          tool.version,
+          tool.installation,
+          formatConfigCell(tool, result.metadata.repositoryRoot),
+          filesCell,
+          issueCount > 0 ? import_ansis.default.bold.red(String(issueCount)) : String(issueCount),
+          `${durationMs}ms`
+        ]);
+      }
+      for (const tool of unavailableTools) {
+        table.push([
+          import_ansis.default.dim.red(tool.displayName ?? tool.toolId),
+          "-",
+          "-",
+          "-",
+          "-",
+          import_ansis.default.dim("missing binary"),
+          "-"
+        ]);
+      }
+      lines.push(table.toString());
+    }
+  }
+  const toolsWithHints = result.capability.unavailable.filter((t) => t.remediation);
+  if (toolsWithHints.length > 0) {
+    lines.push("");
+    lines.push(import_ansis.default.bold("To install missing tools:"));
+    for (const tool of toolsWithHints) {
+      lines.push(import_ansis.default.cyan(`  ${tool.displayName ?? tool.toolId}:`));
+      for (const line of tool.remediation.split("\n")) {
+        lines.push(`    ${line}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+var MAX_LINE_LENGTH = 100;
+var MAX_MULTILINE_DISPLAY = 10;
+function formatMultilineIssue(output, issue) {
+  const contentLines = issue.multilineContent;
+  const startLine = issue.line;
+  const totalLines = contentLines.length;
+  let displayLines;
+  let collapsedCount = 0;
+  if (totalLines > MAX_MULTILINE_DISPLAY) {
+    const headCount = 8;
+    const tailCount = 2;
+    collapsedCount = totalLines - headCount - tailCount;
+    displayLines = [
+      ...contentLines.slice(0, headCount).map((c, i) => ({ lineNum: startLine + i, content: c, index: i })),
+      ...contentLines.slice(totalLines - tailCount).map((c, i) => ({
+        lineNum: startLine + totalLines - tailCount + i,
+        content: c,
+        index: totalLines - tailCount + i
+      }))
+    ];
+  } else {
+    displayLines = contentLines.map((c, i) => ({ lineNum: startLine + i, content: c, index: i }));
+  }
+  for (const { lineNum, content, index } of displayLines) {
+    const truncated = truncateLine(content, MAX_LINE_LENGTH);
+    let formatted;
+    if (index === 0) {
+      formatted = highlightSpan(truncated, issue.column);
+    } else if (index === totalLines - 1) {
+      const clampedEnd = issue.endColumn !== void 0 ? Math.min(issue.endColumn, truncated.length + 1) : void 0;
+      formatted = highlightSpan(truncated, 1, clampedEnd);
+    } else {
+      formatted = import_ansis.default.bold(truncated);
+    }
+    output.push(`  ${import_ansis.default.gray(String(lineNum))} | ${formatted}`);
+    if (collapsedCount > 0 && index === 7) {
+      output.push(`  ${import_ansis.default.gray("...")} | ${import_ansis.default.dim(`${collapsedCount} more lines`)}`);
+    }
+  }
+}
+function formatFilesCell(filesRouted) {
+  if (filesRouted === void 0) return "-";
+  if (filesRouted === 0) return import_ansis.default.dim("0");
+  return String(filesRouted);
+}
+function formatConfigCell(tool, repositoryRoot) {
+  if (tool.configSource === "local" && tool.configPath) {
+    const rawPath = import_path4.default.isAbsolute(tool.configPath) ? import_path4.default.relative(repositoryRoot, tool.configPath) : tool.configPath;
+    return rawPath.startsWith("./") ? rawPath : `./${rawPath}`;
+  }
+  if (tool.configSource === "codacy") return "Codacy";
+  return "-";
+}
+function truncateLine(line, maxLen) {
+  if (line.length <= maxLen) return line;
+  return line.slice(0, maxLen) + "...";
+}
+function highlightSpan(lineContent, column, endColumn) {
+  if (!lineContent || column < 1) return lineContent;
+  const start = column - 1;
+  const end = endColumn ? endColumn - 1 : lineContent.length;
+  const before = lineContent.slice(0, start);
+  const span = lineContent.slice(start, end);
+  const after = lineContent.slice(end);
+  return `${before}${import_ansis.default.bold(span)}${after}`;
+}
+function colorSeverity(severity) {
+  switch (severity) {
+    case "Error":
+      return import_ansis.default.hex("#ff6347")(`[${severity}]`);
+    case "High":
+      return import_ansis.default.hex("#ff8c00")(`[${severity}]`);
+    case "Warning":
+      return import_ansis.default.hex("#ffd700")(`[${severity}]`);
+    case "Info":
+      return import_ansis.default.cyan(`[${severity}]`);
+    default:
+      return `[${severity}]`;
+  }
+}
+
+// src/init.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var import_tooling = require("@codacy/tooling");
+
+// src/codacy-yaml.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path5 = __toESM(require("path"));
+var import_yaml = require("yaml");
+async function readCodacyYaml(repositoryRoot) {
+  const candidates = [".codacy.yaml", ".codacy.yml"];
+  let raw = null;
+  for (const filename of candidates) {
+    try {
+      raw = await import_promises2.default.readFile(import_path5.default.join(repositoryRoot, filename), "utf-8");
+      break;
+    } catch {
+    }
+  }
+  if (raw === null) return null;
+  const parsed = (0, import_yaml.parse)(raw);
+  if (parsed == null || typeof parsed !== "object") return null;
+  return extractCodacyYamlConfig(parsed);
+}
+function extractCodacyYamlConfig(raw) {
+  const excludePaths = extractStringArray(raw["exclude_paths"]);
+  const includePaths = extractStringArray(raw["include_paths"]);
+  const engines = /* @__PURE__ */ new Map();
+  const rawEngines = raw["engines"];
+  if (rawEngines != null && typeof rawEngines === "object" && !Array.isArray(rawEngines)) {
+    for (const [engineName, engineValue] of Object.entries(rawEngines)) {
+      if (engineValue != null && typeof engineValue === "object" && !Array.isArray(engineValue)) {
+        const eng = engineValue;
+        engines.set(engineName, {
+          excludePaths: extractStringArray(eng["exclude_paths"]),
+          includePaths: extractStringArray(eng["include_paths"])
+        });
+      }
+    }
+  }
+  return { excludePaths, includePaths, engines };
+}
+function extractStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
+function resolveEngineToAdapter(engineName, adapters2) {
+  const exact = adapters2.find((a) => a.id === engineName);
+  if (exact) return exact.id;
+  const needle = engineName.toLowerCase();
+  const matches = adapters2.filter((a) => {
+    return a.id.toLowerCase().includes(needle) || a.displayName.toLowerCase().includes(needle);
+  });
+  return matches.length === 1 ? matches[0].id : void 0;
+}
+function applyCodacyYamlExcludes(config, yamlConfig, adapters2, logger) {
+  const hasGlobalIncludes = yamlConfig.includePaths.length > 0;
+  const hasEngineIncludes = Array.from(yamlConfig.engines.values()).some(
+    (e) => e.includePaths.length > 0
+  );
+  if (hasGlobalIncludes || hasEngineIncludes) {
+    logger?.warn("include_paths in .codacy.yaml is not yet supported and will be ignored");
+  }
+  const globalExclude = deduplicateStrings([...config.exclude ?? [], ...yamlConfig.excludePaths]);
+  const tools = config.tools.map((tool) => ({ ...tool }));
+  for (const [engineName, engineConfig] of yamlConfig.engines) {
+    if (engineConfig.excludePaths.length === 0) continue;
+    const adapterId = resolveEngineToAdapter(engineName, adapters2);
+    if (!adapterId) {
+      logger?.warn(`Could not resolve .codacy.yaml engine "${engineName}" to a registered adapter`);
+      continue;
+    }
+    const toolEntry = tools.find((t) => t.toolId === adapterId);
+    if (!toolEntry) {
+      continue;
+    }
+    toolEntry.exclude = deduplicateStrings([
+      ...toolEntry.exclude ?? [],
+      ...engineConfig.excludePaths
+    ]);
+  }
+  return {
+    ...config,
+    exclude: globalExclude,
+    tools
+  };
+}
+function deduplicateStrings(arr) {
+  return [...new Set(arr)];
+}
+
+// src/api/client/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "https://app.codacy.com/api/v3",
+  VERSION: "3.1.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// src/api/client/core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/api/client/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve2, reject) => {
+      this.#resolve = resolve2;
+      this.#reject = reject;
+      const onResolve = (value) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        if (this.#resolve) this.#resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        if (this.#reject) this.#reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this.#isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this.#isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this.#isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    if (this.#reject) this.#reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// src/api/client/core/request.ts
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  try {
+    return value instanceof FormData;
+  } catch (e) {
+    return false;
+  }
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process2 = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process2(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process2(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process2(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path8 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path8}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process2 = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process2(key, v));
+      } else {
+        process2(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: options.abortSignal ?? controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// src/api/client/services/AccountService.ts
+var AccountService = class {
+  /**
+   * Get the authenticated user
+   * @returns UserResponse Successful operation
+   * @throws ApiError
+   */
+  static getUser(abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user",
+      abortSignal,
+      errors: {
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Delete the authenticated user
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteUser(abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/user",
+      abortSignal,
+      errors: {
+        401: `Unauthorized`,
+        404: `Not Found`,
+        409: `Conflict`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update the authenticated user
+   * @param requestBody    * @returns UserResponse Successful operation
+   * @throws ApiError
+   */
+  static patchUser(requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/user",
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List organizations for the authenticated user
+   * List organizations for the authenticated user
+   * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns OrganizationListResponse Successful operation
+   * @throws ApiError
+   */
+  static listUserOrganizations(cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/organizations",
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List organizations for the authenticated user
+   * List organizations for the authenticated user
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns OrganizationListResponse Successful operation
+   * @throws ApiError
+   */
+  static listOrganizations(provider, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/organizations/{provider}",
+      path: {
+        "provider": provider
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get organization for the authenticated user
+   * Get organization for the authenticated user
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider   * @returns OrganizationResponse Successful operation
+   * @throws ApiError
+   */
+  static getUserOrganization(provider, remoteOrganizationName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/organizations/{provider}/{remoteOrganizationName}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List emails for the authenticated user
+   * @returns UserEmailsResponse Successful operation
+   * @throws ApiError
+   */
+  static listUserEmails(abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/emails",
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Remove an email from user account
+   * Removes the specified email address from the authenticated user's account. The primary/default email
+   * cannot be removed. A user must always have at least one email address associated with their account.
+   *
+   * @param requestBody Email   * @returns void
+   * @throws ApiError
+   */
+  static removeUserEmail(requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/user/emails/remove",
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Retrieve email notification settings
+   * Returns the current email notification preferences, including per-commit notifications,
+   * pull request notifications, and activity.
+   *
+   * @returns EmailNotificationSettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static getEmailSettings(abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/emails/settings",
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update email notification preferences
+   * Modifies the user's email notification settings. Settings can be updated individually without affecting
+   * other settings. This endpoint allows users to control which events trigger email notifications.
+   *
+   * @param requestBody Email notification preferences to update   * @returns void
+   * @throws ApiError
+   */
+  static updateEmailSettings(requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/user/emails/settings",
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Set an email as default
+   * Designates the specified email as the default email for the authenticated user. This operation will
+   * automatically remove the default status from any previously default email.
+   * Only one email can be default at any time.
+   *
+   * @param requestBody Email   * @returns void
+   * @throws ApiError
+   */
+  static setDefaultEmail(requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/user/emails/set-default",
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List integrations for the authenticated user
+   * List integrations for the authenticated user
+   * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns IntegrationListResponse Successful operation
+   * @throws ApiError
+   */
+  static listUserIntegrations(cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/integrations",
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Delete an integration for the authenticated user
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)   * @returns void
+   * @throws ApiError
+   */
+  static deleteIntegration(provider, abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/user/integrations/{provider}",
+      path: {
+        "provider": provider
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get organization by provider installation id
+   * __Note__ Currently supports only `gh` as the `provider` parameter.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param installationId Identifier of the Codacy installation   * @returns OrganizationResponse Successful operation
+   * @throws ApiError
+   */
+  static getOrganizationByInstallationId(provider, installationId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/installation/{installationId}",
+      path: {
+        "provider": provider,
+        "installationId": installationId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List the [account API tokens](https://docs.codacy.com/codacy-api/api-tokens/) of the authenticated user
+   * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns ApiTokenListResponse Successful operation
+   * @throws ApiError
+   */
+  static getUserApiTokens(cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/user/tokens",
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Create a new [account API token](https://docs.codacy.com/codacy-api/api-tokens/) for the authenticated user
+   * @param requestBody Optional token expiration timestamp   * @returns ApiToken Successful operation
+   * @throws ApiError
+   */
+  static createUserApiToken(requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/user/tokens",
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Delete an [account API token](https://docs.codacy.com/codacy-api/api-tokens/) for the authenticated user by ID
+   * @param tokenId Unique identifier for the API token   * @returns void
+   * @throws ApiError
+   */
+  static deleteUserApiToken(tokenId, abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/user/tokens/{tokenId}",
+      path: {
+        "tokenId": tokenId
+      },
+      abortSignal,
+      errors: {
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+};
+
+// src/api/client/services/AnalysisService.ts
+var AnalysisService = class {
+  /**
+   * List organization repositories with analysis information for the authenticated user
+   * For Bitbucket, you must URL encode the cursor before using it in subsequent API calls, as the pagination comes directly from the Git provider.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param search Filter results by searching for this string* @param repositories **Deprecated:** Use [searchOrganizationRepositoriesWithAnalysis](#searchorganizationrepositorieswithanalysis) instead.* @param segments Filter by a comma-separated list of segment identifiers   * @returns RepositoryWithAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static listOrganizationRepositoriesWithAnalysis(provider, remoteOrganizationName, cursor, limit = 100, search, repositories, segments, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit,
+        "search": search,
+        "repositories": repositories,
+        "segments": segments
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`,
+        502: `Bad Gateway`
+      }
+    });
+  }
+  /**
+   * Search organization repositories with analysis information for the authenticated user
+   * For Bitbucket, you must URL encode the cursor before using it in subsequent API calls, as the pagination comes directly from the Git provider.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param requestBody Search query body* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns RepositoryWithAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static searchOrganizationRepositoriesWithAnalysis(provider, remoteOrganizationName, requestBody, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/search/analysis/organizations/{provider}/{remoteOrganizationName}/repositories",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`,
+        502: `Bad Gateway`
+      }
+    });
+  }
+  /**
+   * Get a repository with analysis information for the authenticated user
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   *    * @returns RepositoryWithAnalysisResponse Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryWithAnalysis(provider, remoteOrganizationName, repositoryName, branch, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis tools settings of a repository
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns AnalysisToolsResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryTools(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get tools with conflicts in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns RepositoryConflictsResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryToolConflicts(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/conflicts",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Configure an analysis tool by enabling and disabling its patterns for a repository.
+   * This endpoint will apply the changes without verifying if the repository belongs to a coding standard.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool* @param requestBody    * @returns void
+   * @throws ApiError
+   */
+  static configureTool(provider, remoteOrganizationName, repositoryName, toolUuid, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        409: `Conflict`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Patterns configuration for (repository, tool). Uses standard if applied, repository settings otherwise.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool* @param languages Comma-separated list of programming languages to filter results by* @param categories Filter by a comma-separated list of code pattern categories. Valid values are `Security`, `ErrorProne`, `CodeStyle`, `Compatibility`, `UnusedCode`, `Complexity`, `Comprehensibility`, `Documentation`, `BestPractice`, and `Performance`.
+   * * @param severityLevels Filter by a comma-separated list of code pattern severity levels. Valid values are `Error`, `High`, `Warning`, and `Info`.* @param tags Filter by a comma-separated list of pattern tags* @param search Filter results by searching for this string* @param enabled Filter by pattern status. Set to `true` to return only enabled patterns, or `false` to return only disabled patterns* @param recommended Filter by recommended status. Set to `true` to return only recommended patterns, or `false` to return only non-recommended patterns* @param sort Field used to sort the tool's code patterns. Valid values are `category`, `recommended`, and `severity`.* @param direction Sort direction. Possible values are 'asc' (ascending) or 'desc' (descending).* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns ConfiguredPatternsListResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryToolPatterns(provider, remoteOrganizationName, repositoryName, toolUuid, languages, categories, severityLevels, tags, search, enabled, recommended, sort, direction, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}/patterns",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid
+      },
+      query: {
+        "languages": languages,
+        "categories": categories,
+        "severityLevels": severityLevels,
+        "tags": tags,
+        "search": search,
+        "enabled": enabled,
+        "recommended": recommended,
+        "sort": sort,
+        "direction": direction,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Bulk updates the code patterns of a tool in a repository.
+   * Use filters to specify the code patterns to update, or omit the filters to update all code patterns.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool* @param requestBody * @param languages Comma-separated list of programming languages to filter results by* @param categories Filter by a comma-separated list of code pattern categories. Valid values are `Security`, `ErrorProne`, `CodeStyle`, `Compatibility`, `UnusedCode`, `Complexity`, `Comprehensibility`, `Documentation`, `BestPractice`, and `Performance`.
+   * * @param severityLevels Filter by a comma-separated list of code pattern severity levels. Valid values are `Error`, `High`, `Warning`, and `Info`.* @param tags Filter by a comma-separated list of pattern tags* @param search Filter results by searching for this string* @param recommended Filter by recommended status. Set to `true` to return only recommended patterns, or `false` to return only non-recommended patterns   * @returns void
+   * @throws ApiError
+   */
+  static updateRepositoryToolPatterns(provider, remoteOrganizationName, repositoryName, toolUuid, requestBody, languages, categories, severityLevels, tags, search, recommended, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}/patterns",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid
+      },
+      query: {
+        "languages": languages,
+        "categories": categories,
+        "severityLevels": severityLevels,
+        "tags": tags,
+        "search": search,
+        "recommended": recommended
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        409: `Conflict`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Patterns configuration for (repository, tool, pattern). Uses standard if applied, repository settings otherwise.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool* @param patternId Pattern identifier   * @returns ConfiguredPatternResponse Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryToolPattern(provider, remoteOrganizationName, repositoryName, toolUuid, patternId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}/patterns/{patternId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid,
+        "patternId": patternId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Patterns overview for tool. Uses standard if applied, repository settings otherwise.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool* @param languages Comma-separated list of programming languages to filter results by* @param categories Filter by a comma-separated list of code pattern categories. Valid values are `Security`, `ErrorProne`, `CodeStyle`, `Compatibility`, `UnusedCode`, `Complexity`, `Comprehensibility`, `Documentation`, `BestPractice`, and `Performance`.
+   * * @param severityLevels Filter by a comma-separated list of code pattern severity levels. Valid values are `Error`, `High`, `Warning`, and `Info`.* @param tags Filter by a comma-separated list of pattern tags* @param search Filter results by searching for this string* @param enabled Filter by pattern status. Set to `true` to return only enabled patterns, or `false` to return only disabled patterns* @param recommended Filter by recommended status. Set to `true` to return only recommended patterns, or `false` to return only non-recommended patterns   * @returns ToolPatternsOverviewResponse Successful operation
+   * @throws ApiError
+   */
+  static toolPatternsOverview(provider, remoteOrganizationName, repositoryName, toolUuid, languages, categories, severityLevels, tags, search, enabled, recommended, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}/patterns/overview",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid
+      },
+      query: {
+        "languages": languages,
+        "categories": categories,
+        "severityLevels": severityLevels,
+        "tags": tags,
+        "search": search,
+        "enabled": enabled,
+        "recommended": recommended
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Patterns with Coding Standards conflicts for tool.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param toolUuid Unique identifier (UUID) for the tool   * @returns RepositoryToolConflictsResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryToolPatternConflicts(provider, remoteOrganizationName, repositoryName, toolUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tools/{toolUuid}/conflicts",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "toolUuid": toolUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the analysis progress of a repository
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   *    * @returns FirstAnalysisOverviewResponse Successful operation
+   * @throws ApiError
+   */
+  static getFirstAnalysisOverview(provider, remoteOrganizationName, repositoryName, branch, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/analysis-progress",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List pull requests from a repository that the user has access to
+   * You can search this endpoint for either `last-updated` (default), `impact` or `merged`
+   *
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param limit Maximum number of items to return* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param search Filter results by searching for this string* @param includeNotAnalyzed If true, also return pull requests that weren't analyzed   * @returns PullRequestWithAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryPullRequests(provider, remoteOrganizationName, repositoryName, limit = 100, cursor, search, includeNotAnalyzed = false, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor,
+        "search": search,
+        "includeNotAnalyzed": includeNotAnalyzed
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get pull request from a repository
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns PullRequestWithAnalysis Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryPullRequest(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Return analysis results for the commits in a pull request
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number* @param limit Maximum number of items to return* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)   * @returns CommitWithAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static getPullRequestCommits(provider, remoteOrganizationName, repositoryName, pullRequestNumber, limit = 100, cursor, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/commits",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Bypass analysis status in a pull request
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns void
+   * @throws ApiError
+   */
+  static bypassPullRequestAnalysis(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/bypass",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List all coverage reports uploaded for the common ancestor commit and head commit of a pull request branch
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns CoveragePullRequestResponse Successful operation
+   * @throws ApiError
+   */
+  static getPullRequestCoverageReports(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/coverage/status",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List issues found in a pull request
+   * Use the status parameter to filter by new or fixed issues
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number* @param status Filter issues by status. Valid values are `all`, `new`, or `fixed`.* @param onlyPotential Set to `true` to return only potential issues* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns PullRequestIssuesResponse Successful operation
+   * @throws ApiError
+   */
+  static listPullRequestIssues(provider, remoteOrganizationName, repositoryName, pullRequestNumber, status, onlyPotential, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/issues",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      query: {
+        "status": status,
+        "onlyPotential": onlyPotential,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List duplicate code blocks found in a pull request
+   * Use the status parameter to filter by new or removed duplicates
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number* @param status Filter issues by status. Valid values are `all`, `new`, or `fixed`.* @param onlyPotential Set to `true` to return only potential issues* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns ClonesResponse Successful operation
+   * @throws ApiError
+   */
+  static listPullRequestClones(provider, remoteOrganizationName, repositoryName, pullRequestNumber, status, onlyPotential, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/clones",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      query: {
+        "status": status,
+        "onlyPotential": onlyPotential,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List duplicate code blocks found in a commit
+   * Use the status parameter to filter by new or removed duplicates
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA identifier of the source commit* @param status Filter issues by status. Valid values are `all`, `new`, or `fixed`.* @param onlyPotential Set to `true` to return only potential issues* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns ClonesResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitClones(provider, remoteOrganizationName, repositoryName, commitUuid, status, onlyPotential, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/clones",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      query: {
+        "status": status,
+        "onlyPotential": onlyPotential,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis logs for a pull request
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns LogsResponse Successful operation
+   * @throws ApiError
+   */
+  static listPullRequestLogs(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/logs",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis logs for a commit
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA identifier of the source commit   * @returns LogsResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitLogs(provider, remoteOrganizationName, repositoryName, commitUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/logs",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * @deprecated
+   * Get quality settings for the specific repository
+   * **Deprecated:** Use [getQualitySettingsForRepository](#getqualitysettingsforrepository) instead.
+   *
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns DeprecatedRepositoryQualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/quality-settings",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List files of a commit with analysis results
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   * * @param filter Optional field to filter the results. The possible values are empty (default, return files changed in the commit or with coverage changes) or `withCoverageChanges` (return files with coverage changes)
+   * * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param search Filter files that include this string anywhere in their relative path* @param sortColumn Field used to sort the results. The possible values are `deltaCoverage` (to sort by the coverage variation value of the files), `totalCoverage` (to sort by the total coverage value of the files) or `filename` (default - to sort by the name of the files)
+   * * @param columnOrder Sort direction. The possible values are `asc` (ascending - default) or `desc` (descending).   * @returns FileAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitFiles(provider, remoteOrganizationName, repositoryName, commitUuid, branch, filter, cursor, limit = 100, search, sortColumn = "filename", columnOrder = "asc", abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/files",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      query: {
+        "branch": branch,
+        "filter": filter,
+        "cursor": cursor,
+        "limit": limit,
+        "search": search,
+        "sortColumn": sortColumn,
+        "columnOrder": columnOrder
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List files of a pull request with analysis results
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param sortColumn Field used to sort the results. The possible values are `deltaCoverage` (to sort by the coverage variation value of the files), `totalCoverage` (to sort by the total coverage value of the files) or `filename` (default - to sort by the name of the files)
+   * * @param columnOrder Sort direction. The possible values are `asc` (ascending - default) or `desc` (descending).   * @returns FileAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static listPullRequestFiles(provider, remoteOrganizationName, repositoryName, pullRequestNumber, cursor, limit = 100, sortColumn = "filename", columnOrder = "asc", abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/files",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit,
+        "sortColumn": sortColumn,
+        "columnOrder": columnOrder
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List organization pull requests from repositories that the user has access to
+   * You can sort by `last-updated` (default), `impact`, or `merged`
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param limit Maximum number of items to return* @param search Filter results by searching for this string* @param repositories **Deprecated:** Use [searchOrganizationRepositoriesWithAnalysis](#searchorganizationrepositorieswithanalysis) instead.   * @returns PullRequestWithAnalysisListResponse Successful operation
+   * @throws ApiError
+   */
+  static listOrganizationPullRequests(provider, remoteOrganizationName, limit = 100, search, repositories, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/pull-requests",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName
+      },
+      query: {
+        "limit": limit,
+        "search": search,
+        "repositories": repositories
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List commit analysis statistics for the last n days that have analysis data
+   * Returns the last `n` days with available data. This means that the returned days may not match the last `n` calendar days.
+   *
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   * * @param days Number of days of data to return (1-365, defaults to 31)   * @returns CommitAnalysisStatsListResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitAnalysisStats(provider, remoteOrganizationName, repositoryName, branch, days = 31, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commit-statistics",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch,
+        "days": days
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List analysis category overviews for a repository that the user has access to
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   *    * @returns CategoryOverviewListResponse Successful operation
+   * @throws ApiError
+   */
+  static listCategoryOverviews(provider, remoteOrganizationName, repositoryName, branch, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/category-overviews",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List issues in a repository
+   * Returns information about the issues that Codacy found in a repository as available on the [Issues page](https://docs.codacy.com/repositories/issues-view/).
+   * Use [SearchRepositoryIssuesBody](#tocssearchrepositoryissuesbody) to filter the returned issues.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param requestBody Only return issues matching these filters   * @returns SearchRepositoryIssuesListResponse List of issues in the repository
+   * @throws ApiError
+   */
+  static searchRepositoryIssues(provider, remoteOrganizationName, repositoryName, cursor, limit = 100, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/search",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Bulk ignore issues in a repository
+   * Receives a list of issue ids and ignores them in the specified repository. Limited to 50 issues at once
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody List of issue ids to ignore   * @returns void
+   * @throws ApiError
+   */
+  static bulkIgnoreIssues(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/bulk-ignore",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get an overview of the issues in a repository
+   * Returns information about the number of issues that Codacy found in a repository as available on the [Issues page](https://docs.codacy.com/repositories/issues-view/).
+   * Use [SearchRepositoryIssuesBody](#tocssearchrepositoryissuesbody) to filter the returned issues.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody Only return issues matching these filters   * @returns IssuesOverviewResponse Overview of the issues in the repository
+   * @throws ApiError
+   */
+  static issuesOverview(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/overview",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get information about an open issue in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param issueId Identifier of an open issue   * @returns GetIssueResponse An issue found in a repository.
+   * @throws ApiError
+   */
+  static getIssue(provider, remoteOrganizationName, repositoryName, issueId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/{issueId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "issueId": issueId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Ignore or unignore an issue
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param issueId Issue identifier* @param requestBody New ignored status of the issue   * @returns void
+   * @throws ApiError
+   */
+  static updateIssueState(provider, remoteOrganizationName, repositoryName, issueId, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/{issueId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "issueId": issueId
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Ignore the false positive result in an issue
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param issueId Issue identifier   * @returns void
+   * @throws ApiError
+   */
+  static ignoreFalsePositive(provider, remoteOrganizationName, repositoryName, issueId, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/{issueId}/false-positive/ignore",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "issueId": issueId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        409: `Conflict`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List ignored issues in a repository
+   * Ignored issues are issues that Codacy found but were marked as ignored on the Codacy UI. Use [SearchRepositoryIssuesBody](#tocssearchrepositoryissuesbody) to filter results.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param requestBody Only return issues matching these filters   * @returns IgnoredIssuesListResponse List of ignored issues in the repository
+   * @throws ApiError
+   */
+  static searchRepositoryIgnoredIssues(provider, remoteOrganizationName, repositoryName, cursor, limit = 100, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/ignoredIssues/search",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Return analysis results for the commits in a branch
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   * * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns CommitWithAnalysisListResponse List of commits with analysis results
+   * @throws ApiError
+   */
+  static listRepositoryCommits(provider, remoteOrganizationName, repositoryName, branch, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis results for a commit
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit   * @returns CommitWithAnalysis Successful operation
+   * @throws ApiError
+   */
+  static getCommit(provider, remoteOrganizationName, repositoryName, commitUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis statistics of a commit
+   * Returns the quality metric deltas introduced by a commit. The values of the metrics are 0 or null if Codacy didn't analyze the commit yet.
+   * To obtain the full analysis statistics for the repository use the endpoint [getRepositoryWithAnalysis](#getrepositorywithanalysis).
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit   * @returns CommitDeltaStatistics Successful operation
+   * @throws ApiError
+   */
+  static getCommitDeltaStatistics(provider, remoteOrganizationName, repositoryName, commitUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/deltaStatistics",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List the issues introduced or fixed by a commit
+   * Returns a list of issues introduced or fixed given a source commit SHA. By default, Codacy will calculate the issues by creating a delta between the source commit and its parent commit. As an alternative, you can also provide a destination commit to calculate the deltas.
+   * To list all issues in the repository, use [searchRepositoryIssues](#searchrepositoryissues).
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param srcCommitUuid UUID or SHA string that identifies the source commit* @param targetCommitUuid UUID or SHA string that identifies the target commit* @param status Filter issues by status. Valid values are `all`, `new`, or `fixed`.* @param onlyPotential Set to `true` to return only potential issues* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns CommitDeltaIssuesResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitDeltaIssues(provider, remoteOrganizationName, repositoryName, srcCommitUuid, targetCommitUuid, status, onlyPotential, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{srcCommitUuid}/deltaIssues",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "srcCommitUuid": srcCommitUuid
+      },
+      query: {
+        "targetCommitUuid": targetCommitUuid,
+        "status": status,
+        "onlyPotential": onlyPotential,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * @deprecated
+   * Get information about a commit
+   * Use `/commits/{commitId}` instead.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param commitId Identifier of the commit   * @returns CommitDetails Details about the commit.
+   * @throws ApiError
+   */
+  static getCommitDetails(provider, remoteOrganizationName, commitId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/commit/{commitId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "commitId": commitId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get information about a commit
+   * @param commitId Identifier of the commit   * @returns CommitDetailsV2 Details about the commit.
+   * @throws ApiError
+   */
+  static getCommitDetailsByCommitId(commitId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/commits/{commitId}",
+      path: {
+        "commitId": commitId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Check if the repository has quick fix suggestions for a branch
+   * If branch is not provided, the default branch is used.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   *    * @returns HasQuickfixSuggestionsResponse Successful operation
+   * @throws ApiError
+   */
+  static hasQuickfixSuggestions(provider, remoteOrganizationName, repositoryName, branch, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/hasSuggestions",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get quickfixes for issues in patch format
+   * If branch is not provided, the default branch is used.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   *    * @returns QuickfixPatchResponse Successful operation
+   * @throws ApiError
+   */
+  static getQuickfixesPatch(provider, remoteOrganizationName, repositoryName, branch, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/issues/patch",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get quickfixes for pull request issues in patch format
+   * If branch is not provided, the default branch is used.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns QuickfixPatchResponse Successful operation
+   * @throws ApiError
+   */
+  static getPullRequestQuickfixesPatch(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/analysis/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/issues/patch",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+};
+
+// src/api/client/services/RepositoryService.ts
+var RepositoryService = class {
+  /**
+   * Follow a repository that was already added to Codacy
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns AddedStateResponse Successful operation
+   * @throws ApiError
+   */
+  static followAddedRepository(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/follow",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Unfollow a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns void
+   * @throws ApiError
+   */
+  static unfollowRepository(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/follow",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get quality settings for the specific repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns RepositoryQualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static getQualitySettingsForRepository(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/repository",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update quality goals settings for the specific repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody The new value for the quality goals of the repository   * @returns RepositoryQualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static updateRepositoryQualitySettings(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/repository",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Regenerate the user SSH key that Codacy uses to clone the repository
+   * Codacy automatically adds the new public user SSH key to the user account on the Git provider. Using a user SSH key is recommended if your repository includes submodules.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns SshKeySettingResponse Successful operation
+   * @throws ApiError
+   */
+  static regenerateUserSshKey(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/ssh-user-key",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Regenerate the SSH key that Codacy uses to clone the repository
+   * Codacy automatically adds the new public SSH key to the repository on the Git provider.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns SshKeySettingResponse Successful operation
+   * @throws ApiError
+   */
+  static regenerateRepositorySshKey(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/ssh-repository-key",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the public SSH key for the repository
+   * The returned key is the most recently generated and can be either a user or repository SSH key.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns SshKeySettingResponse Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryPublicSshKey(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/stored-ssh-key",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Synchronize repository name and visibility with Git provider
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns SyncProviderSettingResponse Successful operation
+   * @throws ApiError
+   */
+  static syncRepositoryWithProvider(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/sync",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the status of the repository setting **Run analysis on your build server**
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns BuildServerAnalysisSettingResponse Successful operation
+   * @throws ApiError
+   */
+  static getBuildServerAnalysisSetting(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/analysis",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        405: `Method Not Allowed`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update the status of the repository setting **Run analysis on your build server**
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody New value for the repository setting **Run analysis on your build server**   * @returns BuildServerAnalysisSettingResponse Successful operation
+   * @throws ApiError
+   */
+  static updateBuildServerAnalysisSetting(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/analysis",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        405: `Method Not Allowed`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get quality settings for the commits of a repository
+   * `diffCoverageThreshold` is never returned because this threshold isn't currently supported for commits.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static getCommitQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/commits",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update quality settings for the commits of a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody The new value for the quality settings of commits in a repository   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static updateCommitQualitySettings(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/commits",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Reset quality settings for the commits of a repository to Codacy’s default values
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static resetCommitsQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/commits/reset",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Reset quality settings for the pull requests of a repository to Codacy’s default values
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static resetPullRequestsQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/pull-requests/reset",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Reset quality settings for the repository to Codacy’s default values
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns RepositoryQualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static resetRepositoryQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/repository/reset",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get quality settings for the pull requests of a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static getPullRequestQualitySettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/pull-requests",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update quality settings for the pull requests of a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody The new value for the quality settings of pull requests in the repository   * @returns QualitySettingsResponse Successful operation
+   * @throws ApiError
+   */
+  static updatePullRequestQualitySettings(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/settings/quality/pull-requests",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get Git provider integration settings for a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns RepositoryIntegrationSettings Successful operation
+   * @throws ApiError
+   */
+  static getRepositoryIntegrationsSettings(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/integrations/providerSettings",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`,
+        502: `Bad Gateway`
+      }
+    });
+  }
+  /**
+   * Update Git provider integration settings for a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody    * @returns void
+   * @throws ApiError
+   */
+  static updateRepositoryIntegrationsSettings(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/integrations/providerSettings",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`,
+        502: `Bad Gateway`
+      }
+    });
+  }
+  /**
+   * Create a [post-commit hook](https://docs.codacy.com/repositories-configure/integrations/post-commit-hooks/) for a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns void
+   * @throws ApiError
+   */
+  static createPostCommitHook(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/integrations/postCommitHook",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `An unexpected error occurred while creating the post-commit hook`
+      }
+    });
+  }
+  /**
+   * Refresh the Git provider integration for a repository (GitLab and Bitbucket only)
+   * Codacy will use the authenticated user to create comments on new pull requests
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns void
+   * @throws ApiError
+   */
+  static refreshProviderRepositoryIntegration(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/integrations/refreshProvider",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `An unexpected error occurred while refreshing the repository Git provider integration`
+      }
+    });
+  }
+  /**
+   * Reanalyze a specific commit in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody UUID or SHA string that identifies the commit   * @returns void
+   * @throws ApiError
+   */
+  static reanalyzeCommitById(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/reanalyzeCommit",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Fetch the specified repository
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns RepositoryResponse Successful operation
+   * @throws ApiError
+   */
+  static getRepository(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Delete the specified repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns void
+   * @throws ApiError
+   */
+  static deleteRepository(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List repository branches
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param enabled Filter by branch status. Set to `true` to return only enabled branches, or `false` to return only disabled branches* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param search Filter results by searching for this string* @param sort Field used to sort the list of branches. The allowed values are 'name' and 'last-updated'.* @param direction Sort direction. Possible values are 'asc' (ascending) or 'desc' (descending).   * @returns BranchListResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryBranches(provider, remoteOrganizationName, repositoryName, enabled, cursor, limit = 100, search, sort, direction, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/branches",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "enabled": enabled,
+        "cursor": cursor,
+        "limit": limit,
+        "search": search,
+        "sort": sort,
+        "direction": direction
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Update the settings for a repository branch
+   * Toggle analysis for a branch.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branchName Repository branch name* @param requestBody    * @returns void
+   * @throws ApiError
+   */
+  static updateRepositoryBranchConfiguration(provider, remoteOrganizationName, repositoryName, branchName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/branches/{branchName}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "branchName": branchName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Set branch as default
+   * Sets the default branch for a repository. The new default branch must already be enabled on Codacy.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branchName Repository branch name   * @returns void
+   * @throws ApiError
+   */
+  static setRepositoryBranchAsDefault(provider, remoteOrganizationName, repositoryName, branchName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/branches/{branchName}/setDefault",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "branchName": branchName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get branch required status checks
+   * Get branch required status checks
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branchName Repository branch name   * @returns BranchRequiredChecksResponse Successful operation
+   * @throws ApiError
+   */
+  static getBranchRequiredChecks(provider, remoteOrganizationName, repositoryName, branchName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/branches/{branchName}/required-checks",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "branchName": branchName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Create a pull request adding the Codacy analysis badge to the repository
+   * Creates a pull request adding the Codacy static code analysis badge
+   * to the README of the GitHub repository if the repository is public
+   * and doesn't already have a badge.
+   *
+   * **Note:** The pull request is created asynchronously and may fail
+   * even if this endpoint responds successfully.
+   *
+   * @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns void
+   * @throws ApiError
+   */
+  static createBadgePullRequest(remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/gh/{remoteOrganizationName}/repositories/{repositoryName}/badge",
+      path: {
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Add a repository to Codacy
+   * Add a new repository to an existing organization on Codacy
+   * @param requestBody Information of repository to add* @param caller Optional identifier for the calling application or service.   * @returns Repository Successful operation
+   * @throws ApiError
+   */
+  static addRepository(requestBody, caller, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/repositories",
+      headers: {
+        "caller": caller
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        402: `PaymentRequired`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        409: `Conflict`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List files in a repository
+   * Returns the most recent analysis information for the files in a repository as available on the [Files page](https://docs.codacy.com/repositories/files-view/).
+   * Files that are [ignored on Codacy](https://docs.codacy.com/repositories-configure/ignoring-files/) aren't returned.
+   *
+   * **Note:** When applied to public repositories, this operation does not require authentication.
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   * * @param search Filter files that include this string anywhere in their relative path* @param sort Field used to sort the list of files. Valid values are `filename`, `issues`, `grade`, `duplication`, `complexity`, and `coverage`.* @param direction Sort direction. Possible values are 'asc' (ascending) or 'desc' (descending).* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns FileListResponse List of files in the repository
+   * @throws ApiError
+   */
+  static listFiles(provider, remoteOrganizationName, repositoryName, branch, search, sort, direction, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/files",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch,
+        "search": search,
+        "sort": sort,
+        "direction": direction,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List ignored files in a repository
+   * Returns the most recent ignored files information.
+   *
+   * **Note:** When the repository has a Codacy configuration file 'hasCodacyConfigurationFile', this list of files
+   * are read-only, as they were ignored during the most recent analysis based on the configuration file
+   *
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param branch Name of a [repository branch enabled on Codacy](https://docs.codacy.com/repositories-configure/managing-branches/),
+   * as returned by the endpoint [listRepositoryBranches](#listrepositorybranches).
+   * By default, uses the main branch defined on the Codacy repository settings.
+   * * @param search Filter files that include this string anywhere in their relative path* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns IgnoredFileListResponse List of ignored files in the repository
+   * @throws ApiError
+   */
+  static listIgnoredFiles(provider, remoteOrganizationName, repositoryName, branch, search, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/ignored-files",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "branch": branch,
+        "search": search,
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get analysis information and coverage metrics for a file in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param fileId Identifier of a file in a specific commit   * @returns FileInformationWithAnalysis File with analysis
+   * @throws ApiError
+   */
+  static getFileWithAnalysis(provider, remoteOrganizationName, repositoryName, fileId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/files/{fileId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "fileId": fileId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the list of duplicated code blocks for a file in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param fileId Identifier of a file in a specific commit* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns FileClonesResponse File clones
+   * @throws ApiError
+   */
+  static getFileClones(provider, remoteOrganizationName, repositoryName, fileId, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/files/{fileId}/duplication",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "fileId": fileId
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the issue list for a file in a repository
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param fileId Identifier of a file in a specific commit* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns SearchRepositoryIssuesListResponse File issues
+   * @throws ApiError
+   */
+  static getFileIssues(provider, remoteOrganizationName, repositoryName, fileId, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/files/{fileId}/issues",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "fileId": fileId
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List the [repository API tokens](https://docs.codacy.com/codacy-api/api-tokens/)
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns ApiTokenListResponse Successful operation
+   * @throws ApiError
+   */
+  static listRepositoryApiTokens(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tokens",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Create a new [repository API token](https://docs.codacy.com/codacy-api/api-tokens/)
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization   * @returns ApiTokenResponse Successful operation
+   * @throws ApiError
+   */
+  static createRepositoryApiToken(provider, remoteOrganizationName, repositoryName, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tokens",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Delete a [repository API token](https://docs.codacy.com/codacy-api/api-tokens/) by ID
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param tokenId Unique identifier for the API token   * @returns void
+   * @throws ApiError
+   */
+  static deleteRepositoryApiToken(provider, remoteOrganizationName, repositoryName, tokenId, abortSignal) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/tokens/{tokenId}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "tokenId": tokenId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List the most recent coverage reports and their status
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param limit Maximum number of items to return   * @returns CoverageReportResponse Successful operation
+   * @throws ApiError
+   */
+  static listCoverageReports(provider, remoteOrganizationName, repositoryName, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/coverage/status",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      query: {
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * List coverage reports for a commit
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns CoverageReportEntryResponse Successful operation
+   * @throws ApiError
+   */
+  static listCommitCoverageReports(provider, remoteOrganizationName, repositoryName, commitUuid, cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/coverage/reports",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get a coverage report with its contents
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit* @param reportUuid UUID string that identifies the coverage report   * @returns CoverageReportContentResponse Successful operation
+   * @throws ApiError
+   */
+  static getCoverageReport(provider, remoteOrganizationName, repositoryName, commitUuid, reportUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/coverage/reports/{reportUuid}",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid,
+        "reportUuid": reportUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get coverage information for a file in the head commit of a repository branch.
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param fileId Identifier of a file in a specific commit   * @returns GetFileCoverageResponse File Coverage
+   * @throws ApiError
+   */
+  static getFileCoverage(provider, remoteOrganizationName, repositoryName, fileId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/files/{fileId}/coverage",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "fileId": fileId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Ignore or unignore a file
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param requestBody    * @returns void
+   * @throws ApiError
+   */
+  static updateFileState(provider, remoteOrganizationName, repositoryName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/file",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the human-readable Git diff of a pull request
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param pullRequestNumber Pull request number   * @returns DiffResponse Successful operation
+   * @throws ApiError
+   */
+  static getPullRequestDiff(provider, remoteOrganizationName, repositoryName, pullRequestNumber, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/pull-requests/{pullRequestNumber}/diff",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "pullRequestNumber": pullRequestNumber
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the human-readable Git diff of a commit
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param commitUuid UUID or SHA string that identifies the commit   * @returns DiffResponse Successful operation
+   * @throws ApiError
+   */
+  static getCommitDiff(provider, remoteOrganizationName, repositoryName, commitUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/commits/{commitUuid}/diff",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "commitUuid": commitUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Get the human-readable Git diff between a head commit and a base commit
+   * @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param repositoryName Repository name on the Git provider organization* @param baseCommitUuid UUID or SHA string that identifies the base commit for a comparison* @param headCommitUuid UUID or SHA string that identifies the head commit for a comparison   * @returns DiffResponse Successful operation
+   * @throws ApiError
+   */
+  static getDiffBetweenCommits(provider, remoteOrganizationName, repositoryName, baseCommitUuid, headCommitUuid, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/organizations/{provider}/{remoteOrganizationName}/repositories/{repositoryName}/base/{baseCommitUuid}/head/{headCommitUuid}/diff",
+      path: {
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName,
+        "repositoryName": repositoryName,
+        "baseCommitUuid": baseCommitUuid,
+        "headCommitUuid": headCommitUuid
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        403: `Forbidden`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+};
+
+// src/api/client/services/ToolsService.ts
+var ToolsService = class {
+  /**
+   * Retrieve the list of tools
+   * @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return   * @returns ToolListResponse Successful operation
+   * @throws ApiError
+   */
+  static listTools(cursor, limit = 100, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/tools",
+      query: {
+        "cursor": cursor,
+        "limit": limit
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Retrieve the list of tool patterns
+   * @param toolUuid Unique identifier (UUID) for the tool* @param cursor Cursor to [specify a batch of results to request](https://docs.codacy.com/codacy-api/using-the-codacy-api/#using-pagination)* @param limit Maximum number of items to return* @param enabled Filter by enabled status. Set to `true` to return only enabled patterns, or `false` to return only disabled patterns.   * @returns PatternListResponse Successful operations
+   * @throws ApiError
+   */
+  static listPatterns(toolUuid, cursor, limit = 100, enabled, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/tools/{toolUuid}/patterns",
+      path: {
+        "toolUuid": toolUuid
+      },
+      query: {
+        "cursor": cursor,
+        "limit": limit,
+        "enabled": enabled
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Add feedback relating to the tool pattern
+   * Add feedback relating to the tool pattern.
+   *
+   * @param toolUuid Unique identifier (UUID) for the tool* @param patternId Pattern identifier* @param provider Git provider identifier (e.g., gh for GitHub, gl for GitLab, bb for Bitbucket)* @param remoteOrganizationName Organization name on the Git provider* @param requestBody    * @returns any Successful operation
+   * @throws ApiError
+   */
+  static addPatternFeedback(toolUuid, patternId, provider, remoteOrganizationName, requestBody, abortSignal) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/tools/{toolUuid}/patterns/{patternId}/organizations/{provider}/{remoteOrganizationName}/feedback",
+      path: {
+        "toolUuid": toolUuid,
+        "patternId": patternId,
+        "provider": provider,
+        "remoteOrganizationName": remoteOrganizationName
+      },
+      abortSignal,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request`,
+        401: `Unauthorized`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Retrieve a tool pattern
+   * Get the definition of a specific pattern
+   * @param toolUuid Unique identifier (UUID) for the tool* @param patternId Pattern identifier   * @returns PatternResponse Successful operation
+   * @throws ApiError
+   */
+  static getPattern(toolUuid, patternId, abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/tools/{toolUuid}/patterns/{patternId}",
+      path: {
+        "toolUuid": toolUuid,
+        "patternId": patternId
+      },
+      abortSignal,
+      errors: {
+        400: `Bad Request`,
+        404: `Not Found`,
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Retrieve the list of duplication tools
+   * @returns DuplicationToolListResponse Successful operation
+   * @throws ApiError
+   */
+  static listDuplicationTools(abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/duplicationTools",
+      abortSignal,
+      errors: {
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+  /**
+   * Retrieve the list of metrics tools
+   * @returns MetricsToolListResponse Successful operation
+   * @throws ApiError
+   */
+  static listMetricsTools(abortSignal) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/metricsTools",
+      abortSignal,
+      errors: {
+        422: `Unprocessable Entity`,
+        500: `Internal Server Error`
+      }
+    });
+  }
+};
+
+// src/api/index.ts
+function configureApiToken(token) {
+  OpenAPI.HEADERS = { "api-token": token };
+}
+async function fetchAllPages(fetcher) {
+  const results = [];
+  let cursor = void 0;
+  while (true) {
+    const page = await fetcher(cursor);
+    results.push(...page.data);
+    cursor = page.pagination?.cursor;
+    if (!cursor || page.data.length === 0) break;
+  }
+  return results;
+}
+async function validateApiToken(token) {
+  configureApiToken(token);
+  const response = await AccountService.getUser();
+  return { valid: true, name: response.data.name, email: response.data.mainEmail };
+}
+async function listTools() {
+  return fetchAllPages((cursor) => ToolsService.listTools(cursor, 100));
+}
+async function listPatterns(toolUuid) {
+  return fetchAllPages((cursor) => ToolsService.listPatterns(toolUuid, cursor, 100));
+}
+async function getRepository(provider, org, repo) {
+  const response = await RepositoryService.getRepository(provider, org, repo);
+  return response.data;
+}
+async function listRepositoryTools(provider, org, repo) {
+  const response = await AnalysisService.listRepositoryTools(provider, org, repo);
+  return response.data.filter((t) => t.settings.isEnabled);
+}
+async function listRepositoryToolPatterns(provider, org, repo, toolUuid) {
+  const all = await fetchAllPages(
+    (cursor) => AnalysisService.listRepositoryToolPatterns(
+      provider,
+      org,
+      repo,
+      toolUuid,
+      void 0,
+      // languages
+      void 0,
+      // categories
+      void 0,
+      // severityLevels
+      void 0,
+      // tags
+      void 0,
+      // search
+      true,
+      // enabled — fetch only enabled patterns
+      void 0,
+      // recommended
+      void 0,
+      // sort
+      void 0,
+      // direction
+      cursor,
+      100
+    )
+  );
+  return all;
+}
+
+// src/init.ts
+async function detectLanguages(repositoryRoot) {
+  let files = [];
+  try {
+    const output = (0, import_child_process2.execSync)("git ls-files", {
+      cwd: repositoryRoot,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    }).trim();
+    files = output ? output.split("\n") : [];
+  } catch {
+    return [];
+  }
+  const detected = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const basename = import_path6.default.basename(file);
+    const ext = import_path6.default.extname(file).toLowerCase();
+    for (const [lang, config] of Object.entries(import_tooling.LANGUAGE_CONFIG)) {
+      if (config.extensions.includes(ext)) {
+        detected.add(lang);
+      } else if (config.files.includes(basename)) {
+        detected.add(lang);
+      }
+    }
+  }
+  return Array.from(detected).sort();
+}
+async function detectLocalConfigFiles(repositoryRoot, adapters2) {
+  const found = /* @__PURE__ */ new Map();
+  const checks = await Promise.allSettled(
+    adapters2.map(async (adapter) => {
+      const result = await adapter.checkLocalConfigurationFile({
+        repositoryRoot,
+        generatedConfigDir: import_path6.default.join(repositoryRoot, ".codacy", "generated"),
+        globalDir: import_path6.default.join(process.env.HOME ?? "~", ".codacy"),
+        toolInstallDir: import_path6.default.join(process.env.HOME ?? "~", ".codacy", "tools", adapter.id),
+        targetFiles: [],
+        platform: { os: process.platform, arch: process.arch },
+        logger: silentLogger,
+        runner: "local"
+      });
+      return { toolId: adapter.id, result };
+    })
+  );
+  for (const outcome of checks) {
+    if (outcome.status === "fulfilled" && outcome.value.result.found && outcome.value.result.path) {
+      found.set(outcome.value.toolId, outcome.value.result.path);
+    }
+  }
+  return found;
+}
+var silentLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+async function enrichWithCodacyYaml(config, repositoryRoot, adapters2) {
+  const yamlConfig = await readCodacyYaml(repositoryRoot);
+  if (!yamlConfig) return { config, codacyYamlApplied: false };
+  return {
+    config: applyCodacyYamlExcludes(config, yamlConfig, adapters2),
+    codacyYamlApplied: true
+  };
+}
+async function initLocalConfigBase(repositoryRoot, adapters2) {
+  const languages = await detectLanguages(repositoryRoot);
+  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters2);
+  const tools = [];
+  for (const [toolId, configPath] of localConfigs.entries()) {
+    tools.push({
+      toolId,
+      localConfigurationFile: configPath,
+      useLocalConfigurationFile: true,
+      patterns: []
+    });
+  }
+  return createCodacyConfig({ source: "local", languages, tools });
+}
+async function initLocalConfig(repositoryRoot, adapters2) {
+  const baseConfig = await initLocalConfigBase(repositoryRoot, adapters2);
+  const { config, codacyYamlApplied } = await enrichWithCodacyYaml(baseConfig, repositoryRoot, adapters2);
+  return { config, stats: { codacyYamlApplied } };
+}
+async function initDefaultConfig(repositoryRoot, adapters2) {
+  const base = await initLocalConfigBase(repositoryRoot, adapters2);
+  const toolsWithLocalConfig = new Set(
+    base.tools.filter((t) => t.useLocalConfigurationFile).map((t) => t.toolId)
+  );
+  const apiTools = await listTools();
+  const repoLanguages = new Set(base.metadata.languages);
+  const updatedTools = [...base.tools];
+  const coveredToolIds = new Set(updatedTools.map((t) => t.toolId));
+  let addedTools = 0;
+  for (const adapter of adapters2) {
+    if (toolsWithLocalConfig.has(adapter.id)) continue;
+    const apiTool = apiTools.find(
+      (t) => t.prefix ? t.prefix.replace(/_$/, "") === adapter.id : t.name === adapter.id
+    );
+    if (!apiTool) continue;
+    if (!apiTool.enabledByDefault) continue;
+    if (apiTool.languages.length > 0 && repoLanguages.size > 0) {
+      const hasOverlap = apiTool.languages.some((lang) => repoLanguages.has(lang));
+      if (!hasOverlap) continue;
+    }
+    let patterns = [];
+    try {
+      const apiPatterns = await listPatterns(apiTool.uuid);
+      patterns = apiPatterns.filter((p) => p.enabled).map((p) => ({ patternId: p.id }));
+    } catch {
+    }
+    if (!coveredToolIds.has(adapter.id)) {
+      updatedTools.push({
+        toolId: adapter.id,
+        patterns
+      });
+      coveredToolIds.add(adapter.id);
+      addedTools++;
+    }
+  }
+  const baseConfig = createCodacyConfig({ source: "default", languages: base.metadata.languages, tools: updatedTools });
+  const { config, codacyYamlApplied } = await enrichWithCodacyYaml(baseConfig, repositoryRoot, adapters2);
+  return { config, stats: { totalApiTools: apiTools.length, addedTools, codacyYamlApplied } };
+}
+async function initRemoteConfig(repositoryRoot, provider, organization, repositoryName, adapters2, apiToken, onRemoteToolsFound, onToolProcessed) {
+  configureApiToken(apiToken);
+  const repoInfo = await getRepository(provider, organization, repositoryName);
+  const remoteTools = await listRepositoryTools(provider, organization, repositoryName);
+  const adapterByName = /* @__PURE__ */ new Map();
+  for (const adapter of adapters2) {
+    adapterByName.set(adapter.id, adapter);
+    adapterByName.set(adapter.displayName.toLowerCase(), adapter);
+  }
+  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters2);
+  const allApiTools = await listTools();
+  const adapterByUuid = /* @__PURE__ */ new Map();
+  for (const apiTool of allApiTools) {
+    const adapter = apiTool.prefix ? adapterByName.get(apiTool.prefix.replace(/_$/, "")) : adapterByName.get(apiTool.name);
+    if (adapter) {
+      adapterByUuid.set(apiTool.uuid, adapter);
+    }
+  }
+  const matchedAdapterCount = remoteTools.filter((t) => adapterByUuid.has(t.uuid)).length;
+  onRemoteToolsFound?.(remoteTools.length, matchedAdapterCount);
+  const tools = [];
+  let matchedAdapters = 0;
+  for (const remoteTool of remoteTools) {
+    const adapter = adapterByUuid.get(remoteTool.uuid);
+    if (!adapter) continue;
+    matchedAdapters++;
+    const usesLocalConfig = remoteTool.settings.usesConfigurationFile;
+    const localConfigPath = localConfigs.get(adapter.id);
+    let patterns = [];
+    if (!usesLocalConfig) {
+      try {
+        const configuredPatterns = await listRepositoryToolPatterns(
+          provider,
+          organization,
+          repositoryName,
+          remoteTool.uuid
+        );
+        patterns = configuredPatterns.map((cp) => {
+          const params = cp.parameters.length > 0 ? Object.fromEntries(cp.parameters.map((p) => [p.name, p.value])) : void 0;
+          return {
+            patternId: cp.patternDefinition.id,
+            ...params ? { parameters: params } : {}
+          };
+        });
+      } catch {
+      }
+    }
+    onToolProcessed?.(adapter.displayName, patterns.length, usesLocalConfig);
+    tools.push({
+      toolId: adapter.id,
+      ...localConfigPath ? { localConfigurationFile: localConfigPath } : {},
+      // Honour local config when the API says usesConfigurationFile, OR when a
+      // local config exists and no patterns were configured (backwards-compat).
+      ...usesLocalConfig || localConfigPath && patterns.length === 0 ? { useLocalConfigurationFile: true } : {},
+      patterns
+    });
+  }
+  const baseConfig = createCodacyConfig({
+    source: "remote",
+    provider,
+    organization,
+    languages: repoInfo.languages,
+    tools,
+    repositoryId: repoInfo.repositoryId != null ? String(repoInfo.repositoryId) : void 0,
+    repositoryName
+  });
+  const { config, codacyYamlApplied } = await enrichWithCodacyYaml(baseConfig, repositoryRoot, adapters2);
+  return { config, stats: { totalRemoteTools: remoteTools.length, matchedAdapters, codacyYamlApplied } };
+}
+async function initContainerConfig(repositoryRoot, adapters2) {
+  const codacyrcPath = import_path6.default.join(repositoryRoot, ".codacyrc");
+  let raw;
+  try {
+    raw = await import_promises3.default.readFile(codacyrcPath, "utf-8");
+  } catch {
+    throw new Error(`.codacyrc not found at ${codacyrcPath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    try {
+      const decoded = Buffer.from(raw.trim(), "base64").toString("utf-8");
+      parsed = JSON.parse(decoded);
+    } catch {
+      throw new Error(`Failed to parse .codacyrc: not valid JSON or base64-encoded JSON`);
+    }
+  }
+  const includeFiles = Array.isArray(parsed.files) ? parsed.files.filter((f) => typeof f === "string") : [];
+  const adapterById = new Map(adapters2.map((a) => [a.id, a]));
+  const tools = [];
+  if (Array.isArray(parsed.tools)) {
+    for (const toolEntry of parsed.tools) {
+      if (typeof toolEntry !== "object" || toolEntry === null) continue;
+      const entry = toolEntry;
+      const toolId = typeof entry["toolId"] === "string" ? entry["toolId"] : void 0;
+      if (!toolId || !adapterById.has(toolId)) continue;
+      const patterns = [];
+      if (Array.isArray(entry["patterns"])) {
+        for (const p of entry["patterns"]) {
+          if (typeof p === "object" && p !== null && typeof p["patternId"] === "string") {
+            const pe = p;
+            patterns.push({
+              patternId: pe["patternId"],
+              ...pe["parameters"] && typeof pe["parameters"] === "object" ? { parameters: pe["parameters"] } : {}
+            });
+          }
+        }
+      }
+      tools.push({ toolId, patterns });
+    }
+  }
+  return createCodacyConfig({ source: "container", tools, includeFiles });
+}
+
+// src/logger.ts
+var import_fs = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warning: 2,
+  error: 3
+};
+function rotateLogFiles(logsDir, maxFiles) {
+  let entries;
+  try {
+    entries = import_fs.default.readdirSync(logsDir).filter((f) => f.startsWith("analysis-") && f.endsWith(".log"));
+  } catch {
+    return;
+  }
+  if (entries.length <= maxFiles) return;
+  entries.sort();
+  const toRemove = entries.slice(0, entries.length - maxFiles);
+  for (const f of toRemove) {
+    try {
+      import_fs.default.unlinkSync(import_path7.default.join(logsDir, f));
+    } catch {
+    }
+  }
+}
+function fileTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function enrichMessage(message, fields) {
+  if (!fields) return message;
+  const parts = [];
+  if (fields.toolId) parts.push(String(fields.toolId));
+  if (fields.version) parts.push(`v${fields.version}`);
+  if (fields.installation) parts.push(String(fields.installation));
+  if (fields.configSource) parts.push(String(fields.configSource));
+  if (typeof fields.fileCount === "number") parts.push(`${fields.fileCount} files`);
+  if (typeof fields.issueCount === "number") parts.push(`${fields.issueCount} issues`);
+  if (typeof fields.errorCount === "number" && fields.errorCount > 0) parts.push(`${fields.errorCount} errors`);
+  if (typeof fields.totalIssues === "number") parts.push(`${fields.totalIssues} issues`);
+  if (typeof fields.totalErrors === "number" && fields.totalErrors > 0) parts.push(`${fields.totalErrors} errors`);
+  if (typeof fields.durationMs === "number") parts.push(`${(fields.durationMs / 1e3).toFixed(1)}s`);
+  if (fields.reason) parts.push(String(fields.reason));
+  if (fields.error) parts.push(String(fields.error));
+  if (typeof fields.found === "boolean") parts.push(fields.found ? "found" : "not found");
+  if (fields.path && !fields.version) parts.push(String(fields.path));
+  if (parts.length === 0) return message;
+  return `${message} (${parts.join(", ")})`;
+}
+function createLogger(options = {}) {
+  const minLevel = LEVEL_ORDER[options.level ?? "info"];
+  const fileEnabled = options.fileEnabled ?? true;
+  const logsDir = options.logsDir ?? import_path7.default.join(import_os2.default.homedir(), ".codacy", "logs");
+  const maxFileSize = options.maxFileSize ?? 10 * 1024 * 1024;
+  const maxFiles = options.maxFiles ?? 5;
+  const onStderrMessage = options.onStderrMessage;
+  let logFd = null;
+  let bytesWritten = 0;
+  if (fileEnabled) {
+    import_fs.default.mkdirSync(logsDir, { recursive: true });
+    rotateLogFiles(logsDir, maxFiles);
+    const logFilePath = import_path7.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
+    logFd = import_fs.default.openSync(logFilePath, "a");
+  }
+  function log(level, message, fields) {
+    const numLevel = LEVEL_ORDER[level];
+    if (numLevel < minLevel) return;
+    if (fileEnabled && logFd !== null) {
+      const entry = JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        message,
+        ...fields
+      });
+      const buf = Buffer.from(entry + "\n", "utf-8");
+      import_fs.default.writeSync(logFd, buf);
+      bytesWritten += buf.length;
+      if (bytesWritten >= maxFileSize) {
+        import_fs.default.closeSync(logFd);
+        rotateLogFiles(logsDir, maxFiles);
+        const newPath = import_path7.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
+        logFd = import_fs.default.openSync(newPath, "a");
+        bytesWritten = 0;
+      }
+    }
+    const enriched = enrichMessage(message, fields);
+    if (onStderrMessage) {
+      onStderrMessage(enriched, level);
+    } else {
+      process.stderr.write(`  ${enriched}
+`);
+    }
+  }
+  return {
+    debug: (msg, fields) => log("debug", msg, fields),
+    info: (msg, fields) => log("info", msg, fields),
+    warn: (msg, fields) => log("warning", msg, fields),
+    error: (msg, fields) => log("error", msg, fields)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyze,
+  applyCodacyYamlExcludes,
+  buildToolConfig,
+  clearAdapters,
+  configureApiToken,
+  createCodacyConfig,
+  createLogger,
+  detectLanguages,
+  formatOutput,
+  formatTextSummary,
+  getRegisteredAdapters,
+  initContainerConfig,
+  initDefaultConfig,
+  initLocalConfig,
+  initRemoteConfig,
+  readCodacyConfig,
+  readCodacyYaml,
+  registerAdapter,
+  resolveEngineToAdapter,
+  rotateLogFiles,
+  validateApiToken,
+  writeCodacyConfig
+});