@scalar/cli 2.0.1 → 2.1.0

package/chunks/action-STIEAXOE.js

@@ -0,0 +1,53 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/validate/action.ts
+import as from "ansis";
+import prettyjson from "prettyjson";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { validate } from "@scalar/openapi-parser";
+async function validateAction(inputArgument) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const document = await bundle(inputArgument, {
+    plugins: [readFiles(), fetchUrls()],
+    treeShake: false,
+    depth: -1
+  });
+  const result = await validate(document);
+  if (result.valid && result.version) {
+    const endTime = performance.now();
+    output.info().line(
+      as.green(
+        `Matches the OpenAPI specification${as.white(` (OpenAPI ${as.bold(result.version)})`)}
+`
+      )
+    ).line(
+      `${as.green("File validated")} ${as.grey(
+        `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}
+`
+      )}`
+    ).print();
+  } else {
+    output.error().message(prettyjson.render(result.errors)).message(
+      as.red(
+        `File does not match the OpenAPI ${result.version ? `${result.version} ` : ""}specification.`
+      )
+    ).message(
+      as.red(
+        `${as.bold(
+          `${result.errors?.length} error${result.errors && result.errors.length > 1 ? "s" : ""}`
+        )} found.`
+      )
+    ).exit("error");
+  }
+}
+export {
+  validateAction
+};

package/chunks/action-TPBKPHNS.js

@@ -0,0 +1,110 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getProjectDeployments
+} from "./chunk-HQKBZOYU.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import {
+  formatAbsoluteTime
+} from "./chunk-AEFPCC4U.js";
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import "./chunk-2BSG2QHO.js";
+import "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output,
+  printTable
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/deployments/list/action.ts
+import as from "ansis";
+function colorStatus(status) {
+  switch (status) {
+    case "deployed":
+      return as.green(status);
+    case "error":
+    case "cancelled":
+      return as.red(status);
+    case "pending":
+    case "building":
+      return as.yellow(status);
+    default:
+      return as.dim(status);
+  }
+}
+async function listAction(args) {
+  const argsParseResult = external_exports.object({ slug: slugSchema.optional() }).safeParse(args);
+  if (argsParseResult.error) {
+    return output.error().title("Invalid Arguments").message(argsParseResult.error.issues[0].message).exit("error");
+  }
+  const { slug } = argsParseResult.data;
+  if (!slug) {
+    return output.error().title("Invalid argument").message("Slug is required. Try passing --slug flag.").exit("error");
+  }
+  const apiClient = await apiService();
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const resolved = await resolveProject(slug, apiClient);
+  if (resolved.kind === "not-found") {
+    return output.error().title("Project not found").message(`No project with slug "${slug}" was found for your team.`).exit("error");
+  }
+  const { project } = resolved;
+  const activeUid = project.activeDeployment?.uid ?? null;
+  const deploymentsResult = await getProjectDeployments({
+    teamUid: auth.teamUid,
+    projectUid: project.uid
+  });
+  if (!deploymentsResult.success) {
+    return output.error().title("Could not load deployment history").message(deploymentsResult.error).exit("error");
+  }
+  if (deploymentsResult.deployments.length === 0) {
+    output.info().title(`No deployments found for project "${slug}".`).print();
+    return;
+  }
+  printTable(
+    [
+      { name: "current", title: " ", alignment: "center" },
+      { name: "id", title: "Build ID", alignment: "left" },
+      { name: "status", title: "Status", alignment: "left" },
+      { name: "deployed", title: "Deployed", alignment: "left" },
+      { name: "commit", title: "Commit", alignment: "left" }
+    ],
+    deploymentsResult.deployments.map((record) => {
+      const isLive = record.uid === activeUid;
+      const deployedAt = record.deployedAt ?? (record.status === "deployed" ? record.createdAt : null);
+      return {
+        current: isLive ? as.green("\u279C") : " ",
+        id: isLive ? as.green(record.uid) : record.uid,
+        status: colorStatus(record.status),
+        deployed: deployedAt ? formatAbsoluteTime(deployedAt * 1e3) : as.dim("\u2014"),
+        commit: record.commitSha ? record.commitSha.slice(0, 7) : as.dim("\u2014")
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/action-TWFJNQ2R.js

@@ -0,0 +1,95 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import "./chunk-23I5PKZZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  isYamlFileName
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/join/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs/promises";
+import as from "ansis";
+import { join, normalize } from "@scalar/openapi-parser";
+
+// src/domains/document/join/helpers.ts
+var getValueByPath = (input, path) => {
+  return path.reduce((acc, segment) => {
+    if (acc && typeof acc === "object" && acc !== null && segment in acc) {
+      return acc[segment];
+    }
+    return void 0;
+  }, input);
+};
+var getPrefixes = (documents, path) => {
+  const segments = path.split(".");
+  return documents.map((doc) => {
+    const value = getValueByPath(doc, segments);
+    if (value === void 0) {
+      return "";
+    }
+    return String(value);
+  });
+};
+
+// src/domains/document/join/action.ts
+var formatErrorMessage = (conflicts) => {
+  return conflicts.map((conflict) => {
+    if (conflict.type === "component") {
+      return `Component '/${conflict.componentType}/${conflict.name}' has conflicts`;
+    }
+    if (conflict.type === "path") {
+      return `Path '${conflict.path} ${conflict.method}' has conflicts`;
+    }
+    return `Webhook '${conflict.path} ${conflict.method}' has conflicts`;
+  });
+};
+async function joinAction(rawInput, rawOpt) {
+  const { error, data: input } = external_exports.array(external_exports.string()).safeParse(rawInput);
+  if (error) {
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  }
+  const { error: optsError, data: opts } = external_exports.object({
+    output: external_exports.string(),
+    prefixComponentsWithPathValue: external_exports.string().optional()
+  }).safeParse(rawOpt);
+  if (optsError) {
+    return output.error().title("Invalid options").line("").line(
+      optsError.issues.map((e) => `${e.message} property: '${e.path}'`).join("\n")
+    ).line("").exit("error");
+  }
+  const files = (await Promise.all(input.map((file) => fs.readFile(file, "utf-8")))).map((it) => normalize(it));
+  const prefixes = opts.prefixComponentsWithPathValue ? getPrefixes(files, opts.prefixComponentsWithPathValue) : [];
+  const { executionTimeMs, result } = await measureTime(
+    () => join(files, { prefixComponents: prefixes })
+  );
+  if (!result.ok) {
+    return output.error().title("Failed to join OpenAPI documents").line().line(`Conflicts:
+${formatErrorMessage(result.conflicts).join("\n")}`).line().exit("error");
+  }
+  const isYaml = isYamlFileName(opts.output);
+  await fs.writeFile(
+    opts.output,
+    isYaml ? import_yaml.default.stringify(result.document) : JSON.stringify(result.document, null, 2),
+    "utf8"
+  );
+  output.info().message(
+    `${as.green("\u{1F91D} OpenAPI Documents joined")} in ${as.white(`${as.bold(`${Math.round(executionTimeMs)}`)} ms`)}`
+  ).print();
+}
+export {
+  joinAction
+};

package/chunks/action-TZ5KGAQT.js

@@ -0,0 +1,64 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/update/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+async function updateAction(namespace, slug, { title, description }) {
+  const client = await apiService();
+  if (!namespace) {
+    return output.error().title("Invalid input").message("Please provide namespace of the document").exit("error");
+  }
+  if (!slug) {
+    return output.error().title("Invalid input").message("Please provide slug of the document").exit("error");
+  }
+  let titleValue = title;
+  let descriptionValue = description;
+  const shouldPrompt = ![title, description].some((it) => it !== void 0);
+  if (!titleValue && shouldPrompt) {
+    titleValue = await text({
+      message: `What is the new title of your document? ${as.grey("(Optional)")}`
+    });
+  }
+  if (!descriptionValue && shouldPrompt) {
+    descriptionValue = await text({
+      message: `What is the new description of your document?  ${as.grey("(Optional)")}`
+    });
+  }
+  if (!titleValue && !descriptionValue) {
+    return output.error().title("Invalid input").message("Please provide any field to update").exit("error");
+  }
+  const logger = output.info().line().loader("Updating the api document");
+  const updateDocument = await client.managedDocs.update(namespace, slug, {
+    title: titleValue,
+    description: descriptionValue,
+    isPrivate: false
+  });
+  if (updateDocument.error) {
+    return output.error().title(updateDocument.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: "Successfully updated document metadata."
+  }).print();
+}
+export {
+  updateAction
+};

package/chunks/action-UDZUUJSI.js

@@ -0,0 +1,49 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-23I5PKZZ.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  isUrl,
+  isYamlFileName
+} from "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/format/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs";
+import as from "ansis";
+import { normalize, toJson } from "@scalar/openapi-parser";
+async function formatAction(inputArgument, { output: outputPath }) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const specification = await getFileOrUrl(inputArgument);
+  const newContent = isYamlFileName(outputPath || inputArgument) ? (0, import_yaml.stringify)(normalize(specification)) : toJson(normalize(specification));
+  if (outputPath) {
+    fs.writeFileSync(outputPath, newContent, "utf8");
+  } else if (!isUrl(inputArgument)) {
+    fs.writeFileSync(inputArgument, newContent, "utf8");
+  } else {
+    return output.error().title("Invalid argument").message().message(
+      "Output file is required for URLs. Try passing --output file flag."
+    ).exit("error");
+  }
+  const endTime = performance.now();
+  output.info().line(
+    `${as.green("File formatted")} ${as.grey(
+      `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}`
+    )}`
+  ).print();
+}
+export {
+  formatAction
+};

package/chunks/action-W5BATF4Q.js

@@ -0,0 +1,197 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getPublishDeploymentUrl
+} from "./chunk-ZTVWAKNJ.js";
+import {
+  getProjectDeployments
+} from "./chunk-HQKBZOYU.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import {
+  formatAbsoluteTime
+} from "./chunk-AEFPCC4U.js";
+import "./chunk-DOVIWNKQ.js";
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import "./chunk-2BSG2QHO.js";
+import "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/rollback/action.ts
+import { confirm } from "@clack/prompts";
+
+// src/domains/project/rollback/select-rollback-target.ts
+function selectRollbackTarget({
+  deployments,
+  activeUid,
+  to
+}) {
+  const deployed = deployments.filter((record) => record.status === "deployed");
+  if (to) {
+    const target = deployed.find((record) => record.uid === to);
+    if (!target) {
+      const existing = deployments.find((record) => record.uid === to);
+      if (existing) {
+        return {
+          success: false,
+          error: {
+            code: "target-not-deployable",
+            uid: to,
+            status: existing.status
+          }
+        };
+      }
+      return { success: false, error: { code: "target-not-found", uid: to } };
+    }
+    if (target.uid === activeUid) {
+      return { success: false, error: { code: "already-live", uid: to } };
+    }
+    return { success: true, target };
+  }
+  if (deployed.length === 0) {
+    return { success: false, error: { code: "no-history" } };
+  }
+  if (!activeUid) {
+    return { success: false, error: { code: "no-live-deployment" } };
+  }
+  const liveIndex = deployed.findIndex((record) => record.uid === activeUid);
+  if (liveIndex === -1) {
+    return { success: false, error: { code: "no-live-deployment" } };
+  }
+  const previous = deployed[liveIndex + 1];
+  if (!previous) {
+    return { success: false, error: { code: "no-previous" } };
+  }
+  return { success: true, target: previous };
+}
+
+// src/domains/project/rollback/action.ts
+var rollbackArgsSchema = external_exports.object({
+  slug: slugSchema.optional(),
+  to: external_exports.string().trim().min(1, "A build id is required for --to").optional(),
+  yes: external_exports.coerce.boolean().default(false)
+});
+async function rollbackAction(args) {
+  const argsParseResult = rollbackArgsSchema.safeParse(args);
+  if (argsParseResult.error) {
+    return output.error().title("Invalid Arguments").message(argsParseResult.error.issues[0].message).exit("error");
+  }
+  const { slug, to, yes } = argsParseResult.data;
+  if (!slug) {
+    return output.error().title("Invalid argument").message("Slug is required. Try passing --slug flag.").exit("error");
+  }
+  const apiClient = await apiService();
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const resolved = await resolveProject(slug, apiClient);
+  if (resolved.kind === "not-found") {
+    return output.error().title("Project not found").message(`No project with slug "${slug}" was found for your team.`).exit("error");
+  }
+  const { project } = resolved;
+  const activeUid = project.activeDeployment?.uid ?? null;
+  const deploymentsResult = await getProjectDeployments({
+    teamUid: auth.teamUid,
+    projectUid: project.uid
+  });
+  if (!deploymentsResult.success) {
+    return output.error().title("Could not load deployment history").message(deploymentsResult.error).exit("error");
+  }
+  const targetResult = selectRollbackTarget({
+    deployments: deploymentsResult.deployments,
+    activeUid,
+    to
+  });
+  if (!targetResult.success) {
+    if (targetResult.error.code === "already-live") {
+      output.info().title("Already live").message(
+        `Build "${targetResult.error.uid}" is already the live deployment.`
+      ).print();
+      return;
+    }
+    return renderRollbackError(targetResult.error, slug);
+  }
+  const { target } = targetResult;
+  const deployedLabel = formatAbsoluteTime(
+    (target.deployedAt ?? target.createdAt) * 1e3
+  );
+  if (!yes) {
+    const shouldContinue = await confirm({
+      message: `Roll back the live deployment of "${slug}" to build ${target.uid} (${deployedLabel})?`,
+      initialValue: false
+    });
+    if (shouldContinue !== true) {
+      output.info().title("Rollback cancelled.").print();
+      return;
+    }
+  }
+  const logger = output.info({ animate: true }).loader(`Rolling back to build ${target.uid} (${deployedLabel})`);
+  const redeployResult = await apiClient.publish.redeploy(target.uid);
+  if (redeployResult.error) {
+    logger.update("loader", 0, {
+      content: `Rollback to build ${target.uid} failed`
+    });
+    logger.finish();
+    return output.error().title("Rollback failed").message(redeployResult.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: `Rolled back to build ${target.uid} (${deployedLabel})`
+  });
+  logger.finish();
+  const deploymentUrl = getPublishDeploymentUrl(target);
+  if (deploymentUrl) {
+    output.info().line(`Deployment URL: ${deploymentUrl}`).print();
+  }
+}
+function renderRollbackError(error, slug) {
+  switch (error.code) {
+    case "no-history":
+      return output.error().title("Nothing to roll back to").message(
+        `Project "${slug}" has no previous deployed builds. Publish a build first.`
+      ).exit("error");
+    case "no-previous":
+      return output.error().title("Nothing to roll back to").message(
+        `Project "${slug}" is already on its oldest deployed build, so there is no earlier build to roll back to. Run "scalar project deployments list --slug ${slug}" to see all builds, then pass --to <buildId> to deploy a specific one.`
+      ).exit("error");
+    case "no-live-deployment":
+      return output.error().title("No live deployment").message(
+        `Project "${slug}" has no build currently live, so there is no default to roll back to. Pass --to <buildId> to pick a specific build. Run "scalar project deployments list --slug ${slug}" to see available builds.`
+      ).exit("error");
+    case "target-not-found":
+      return output.error().title("Build not found").message(
+        `No deployed build with id "${error.uid}" was found. Run "scalar project deployments list --slug ${slug}" to see available builds.`
+      ).exit("error");
+    case "target-not-deployable":
+      return output.error().title("Build cannot be made live").message(
+        `Build "${error.uid}" has status "${error.status}", so it never finished deploying and cannot be rolled back to. Only builds with status "deployed" can be made live.`
+      ).exit("error");
+  }
+}
+export {
+  rollbackAction,
+  rollbackArgsSchema
+};

package/chunks/agent-XGLOHXNA.js

@@ -0,0 +1,112 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  agentApi,
+  agentApiErrorSchema,
+  analyticsGranularitySchema,
+  analyticsRangeSchema,
+  analyticsRoutes,
+  bumpKindSchema,
+  bumpStrategySchema,
+  docsProjectAgentInfoSchema,
+  docsRoutes,
+  editorChatBodySchema,
+  editorRoutes,
+  installationParamSchema,
+  installationSummarySchema,
+  installationToolSchema,
+  internalRoutes,
+  mcpAnalyticsParamsSchema,
+  mcpCategoryTotalsSchema,
+  mcpConsumerKindSchema,
+  mcpConsumerStatSchema,
+  mcpConsumersResultSchema,
+  mcpDocsPageToolDetailSchema,
+  mcpErrorEntrySchema,
+  mcpErrorsResultSchema,
+  mcpExportDatasetSchema,
+  mcpInstallationRoutes,
+  mcpLatencyByToolEntrySchema,
+  mcpLatencyResultSchema,
+  mcpOperationToolDetailSchema,
+  mcpOverviewResultSchema,
+  mcpOverviewTotalsSchema,
+  mcpServerRoutes,
+  mcpServerWithInstallationsSchema,
+  mcpTimeseriesPointSchema,
+  mcpToolCategorySchema,
+  mcpToolKindSchema,
+  mcpToolStatSchema,
+  mcpToolsResultSchema,
+  mcpVersionRoutes,
+  mcpVersionToolsSchema,
+  openapiRoutes,
+  pubsubPushMessageSchema,
+  pubsubRoutes,
+  pullRequestDescriptionBodySchema,
+  registryDocumentSchema,
+  registryRoutes,
+  registrySearchResultSchema,
+  registryVersionOperationSchema,
+  semverParamSchema,
+  teamUsageResponseSchema,
+  usageRecordSchema,
+  usageRoutes
+} from "./chunk-P646T2WH.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-3MZYUBJ6.js";
+export {
+  agentApi,
+  agentApiErrorSchema,
+  analyticsGranularitySchema,
+  analyticsRangeSchema,
+  analyticsRoutes,
+  bumpKindSchema,
+  bumpStrategySchema,
+  docsProjectAgentInfoSchema,
+  docsRoutes,
+  editorChatBodySchema,
+  editorRoutes,
+  installationParamSchema,
+  installationSummarySchema,
+  installationToolSchema,
+  internalRoutes,
+  mcpAnalyticsParamsSchema,
+  mcpCategoryTotalsSchema,
+  mcpConsumerKindSchema,
+  mcpConsumerStatSchema,
+  mcpConsumersResultSchema,
+  mcpDocsPageToolDetailSchema,
+  mcpErrorEntrySchema,
+  mcpErrorsResultSchema,
+  mcpExportDatasetSchema,
+  mcpInstallationRoutes,
+  mcpLatencyByToolEntrySchema,
+  mcpLatencyResultSchema,
+  mcpOperationToolDetailSchema,
+  mcpOverviewResultSchema,
+  mcpOverviewTotalsSchema,
+  mcpServerRoutes,
+  mcpServerWithInstallationsSchema,
+  mcpTimeseriesPointSchema,
+  mcpToolCategorySchema,
+  mcpToolKindSchema,
+  mcpToolStatSchema,
+  mcpToolsResultSchema,
+  mcpVersionRoutes,
+  mcpVersionToolsSchema,
+  openapiRoutes,
+  pubsubPushMessageSchema,
+  pubsubRoutes,
+  pullRequestDescriptionBodySchema,
+  registryDocumentSchema,
+  registryRoutes,
+  registrySearchResultSchema,
+  registryVersionOperationSchema,
+  semverParamSchema,
+  teamUsageResponseSchema,
+  usageRecordSchema,
+  usageRoutes
+};