@scalar/cli 2.0.1 → 2.5.1

package/chunks/delete.action-VE66JFDS.js

@@ -0,0 +1,96 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import {
+  sdkSchema
+} from "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/delete.action.ts
+import { select } from "@clack/prompts";
+async function deleteAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional()
+  }).safeParse(opts);
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const client = await apiService();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your SDK. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const sdks = await db.getMany({
+    collectionPath: BaseCollections.Sdks(team.data.uid),
+    query: {
+      namespace
+    },
+    schema: sdkSchema.array()
+  });
+  if (sdks.error) return output.error().title(sdks.message).exit("error");
+  const sdkUid = sdks.data.find((sdk) => sdk.slug === data.slug)?.uid || await select({
+    message: "Please select an SDK to delete",
+    options: sdks.data.map((sdk) => ({
+      value: sdk.uid,
+      label: sdk.slug
+    }))
+  });
+  if (!sdkUid) {
+    return output.error().title("No SDK found").message("Please provide a valid SDK slug").exit("error");
+  }
+  const logger = output.info().loader("Deleting the SDK");
+  const response = await client.sdks.delete(sdkUid);
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "SDK deleted successfully!" }).exit("success");
+}
+export {
+  deleteAction
+};

package/chunks/get.action-2745EB4N.js

@@ -0,0 +1,86 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  fetchFromRegistry
+} from "./chunk-UGGNHILG.js";
+import "./chunk-COBPBRQF.js";
+import {
+  registry
+} from "./chunk-XCSR4RIT.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  docVersionSchema,
+  external_exports
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/get.action.ts
+import fs from "node:fs/promises";
+var versionSchema = external_exports.union([docVersionSchema, external_exports.literal("latest")]);
+async function getAction(namespace, slug, args) {
+  if (!namespace) {
+    output.error().title("Invalid input").message("Please provide namespace of the schema").exit("error");
+    return;
+  }
+  if (!slug) {
+    output.error().title("Invalid input").message("Please provide slug of the schema").exit("error");
+    return;
+  }
+  const result = external_exports.object({
+    version: versionSchema,
+    format: external_exports.enum(["json", "yaml"]),
+    output: external_exports.string().min(1).optional()
+  }).safeParse({
+    version: args.version ?? "latest",
+    format: args.format,
+    output: args.output
+  });
+  if (result.error) {
+    output.error().title("Invalid input").message(result.error.issues[0].message).exit("error");
+    return;
+  }
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const fetchResult = await fetchFromRegistry(
+    registry(namespace).schemas(slug).url({
+      version: result.data.version,
+      format: result.data.format
+    }),
+    auth.accessToken
+  );
+  if (fetchResult.error) {
+    output.error().title("Unable to download schema").message(fetchResult.message).exit("error");
+    return;
+  }
+  const document = fetchResult.data;
+  const withTrailingNewline = document.endsWith("\n") ? document : `${document}
+`;
+  if (result.data.output) {
+    try {
+      await fs.writeFile(result.data.output, withTrailingNewline, "utf8");
+    } catch (error) {
+      const message = error instanceof Error && error.message.length > 0 ? error.message : `Could not write to ${result.data.output}.`;
+      output.error().title("Unable to write schema to file").message(message).exit("error");
+      return;
+    }
+    output.info().line(
+      `Downloaded ${namespace}/${slug}@${result.data.version} (${result.data.format})`
+    ).line(`Written to ${result.data.output}`).print();
+    return;
+  }
+  process.stdout.write(withTrailingNewline);
+}
+export {
+  getAction
+};

package/chunks/list.action-3VTXQJRA.js

@@ -0,0 +1,116 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  formatAbsoluteTime
+} from "./chunk-AEFPCC4U.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import {
+  sdkBuildSchema,
+  sdkSchema
+} from "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output,
+  printTable
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/list.action.ts
+import as from "ansis";
+async function listAction(args) {
+  const { error, data } = external_exports.object({
+    namespace: namespaceSchema.optional()
+  }).safeParse({
+    namespace: args.namespace
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const team = await client.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const sdks = await client.getMany({
+    collectionPath: BaseCollections.Sdks(team.data.uid),
+    query: {
+      namespace
+    },
+    schema: sdkSchema.array()
+  });
+  if (sdks.error) return output.error().title(sdks.message).exit("error");
+  if (sdks.data.length === 0) {
+    output.info().title(`No SDKs found for namespace "${namespace}".`).print();
+    return;
+  }
+  const builds = await client.getMany({
+    collectionPath: BaseCollections.SdkBuilds(team.data.uid),
+    query: {},
+    schema: sdkBuildSchema.array()
+  });
+  const lastBuiltAt = /* @__PURE__ */ new Map();
+  if (!builds.error) {
+    for (const build of builds.data) {
+      if (build.createdAt > (lastBuiltAt.get(build.sdk.uid) ?? 0)) {
+        lastBuiltAt.set(build.sdk.uid, build.createdAt);
+      }
+    }
+  }
+  printTable(
+    [
+      { name: "title", title: "Title", alignment: "left", maxLen: 40 },
+      { name: "name", title: "Name", alignment: "left", color: "blue" },
+      { name: "version", title: "Version", alignment: "left" },
+      { name: "access", title: "Access", alignment: "left" },
+      { name: "lastBuild", title: "Last Build", alignment: "left" }
+    ],
+    sdks.data.map((sdk) => {
+      const builtAt = lastBuiltAt.get(sdk.uid);
+      return {
+        title: sdk.title || as.dim("\u2014"),
+        name: `@${sdk.namespace}/${sdk.slug}`,
+        version: sdk.currentVersion,
+        access: sdk.isPrivate ? as.green("Private") : as.yellow("Public"),
+        lastBuild: builtAt ? as.dim(formatAbsoluteTime(builtAt * 1e3)) : as.dim("Never")
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/list.action-4QDCZLSZ.js

@@ -0,0 +1,95 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output,
+  printTable
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  compareVersionsDesc,
+  external_exports,
+  namespaceSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/list.action.ts
+import as from "ansis";
+async function listAction(args) {
+  const { error, data } = external_exports.object({
+    namespace: namespaceSchema.optional()
+  }).safeParse({
+    namespace: args.namespace
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const team = await client.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const apiClient = await apiService();
+  const schemas = await apiClient.managedSchemas.getSchemas(namespace);
+  if (schemas.error) return output.error().title(schemas.message).exit("error");
+  if (schemas.data.length === 0) {
+    output.info().title(`No schemas found for namespace "${namespace}".`).print();
+    return;
+  }
+  printTable(
+    [
+      { name: "title", title: "Title", alignment: "left", maxLen: 40 },
+      { name: "name", title: "Name", alignment: "left", color: "blue" },
+      { name: "version", title: "Version", alignment: "left" },
+      { name: "access", title: "Access", alignment: "left" }
+    ],
+    schemas.data.map((schema) => {
+      const latestVersion = [...schema.versions].sort((a, b) => compareVersionsDesc(a.version, b.version)).at(0);
+      return {
+        title: schema.title || as.dim("\u2014"),
+        name: `@${schema.namespace}/${schema.slug}`,
+        version: latestVersion?.version ?? as.dim("\u2014"),
+        access: schema.isPrivate ? as.green("Private") : as.yellow("Public")
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/publish.action-ULQLZKWU.js

@@ -0,0 +1,190 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  dashboardUrl,
+  registryUrl
+} from "./chunk-COBPBRQF.js";
+import {
+  registry
+} from "./chunk-XCSR4RIT.js";
+import {
+  getFileOrUrl,
+  isDocument,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
+import {
+  DEFAULT_FETCH_CONCURRENCY
+} from "./chunk-K4DTP5TV.js";
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import {
+  RegistryAsset
+} from "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  isUrl
+} from "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  docVersionSchema,
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/publish.action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+async function publishAction(file, args) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    file: external_exports.string().min(1, "Please provide a valid file path or URL for your document.").optional(),
+    title: external_exports.string().max(50).optional(),
+    namespace: namespaceSchema.optional(),
+    private: external_exports.boolean().optional(),
+    version: docVersionSchema.optional(),
+    force: external_exports.coerce.boolean(),
+    bundle: external_exports.coerce.boolean().optional(),
+    fetchLimit: external_exports.coerce.number().optional(),
+    urlMap: external_exports.coerce.boolean().default(false),
+    treeShake: external_exports.coerce.boolean().default(false)
+  }).safeParse({
+    file,
+    title: args.title,
+    slug: args.slug,
+    namespace: args.namespace,
+    private: args.private,
+    version: args.version,
+    force: args.force
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const client = await apiService();
+  const namespaceSchemaRes = await client.managedSchemas.getSchemas(namespace);
+  if (namespaceSchemaRes.error)
+    return output.error().title(namespaceSchemaRes.message).exit("error");
+  const apiFile = data.file || (await text({
+    message: "Please enter a file path or URL for your document",
+    placeholder: "./api.yaml",
+    validate(value) {
+      if (value.length === 0) return "File path or URL is required!";
+    }
+  })).toString();
+  const content = await getFileOrUrl(apiFile);
+  const result = safeNormalize(content);
+  if (!isDocument(result)) {
+    return output.error().title("Invalid file").message(
+      isUrl(apiFile) ? "Could not fetch or parse the document from the URL." : "Could not read or parse the document file."
+    ).exit("error");
+  }
+  const slug = data.slug || (await text({
+    message: "Please provide a slug identifier for your schema",
+    validate(value) {
+      if (value.length === 0) return "Slug is required.";
+      if (slugSchema.safeParse(value)?.error)
+        return "Please enter a valid slug (e.g. my-schema)";
+    }
+  })).toString();
+  const matchingSchema = namespaceSchemaRes.data.find(
+    (schema2) => schema2.slug === slug
+  );
+  const documentTitle = result?.info?.title;
+  const providedTitle = data.title ?? documentTitle;
+  const title = matchingSchema || providedTitle ? providedTitle : (await text({
+    message: "Please provide a title for your schema",
+    validate(value) {
+      if (value.length === 0) return "Title is required.";
+    }
+  })).toString();
+  const version = data.version || (await text({
+    message: "What is the version of your document (e.g. 0.1.0)?",
+    validate(value) {
+      if (value.length === 0) return "Version is required.";
+      if (docVersionSchema.safeParse(value)?.error)
+        return "Version must be a non-empty string";
+    }
+  })).toString();
+  const logger = output.info().line().loader(`Publishing ${slug} to Scalar registry...`);
+  const bundlingPlugins = [readFiles()];
+  if (data.bundle) {
+    bundlingPlugins.push(
+      fetchUrls({
+        limit: data.fetchLimit ?? DEFAULT_FETCH_CONCURRENCY
+      })
+    );
+  }
+  const bundledDocument = await bundle(result, {
+    plugins: bundlingPlugins,
+    treeShake: data.treeShake,
+    urlMap: data.urlMap
+  });
+  const document = JSON.stringify(bundledDocument);
+  const publishRes = matchingSchema ? await client.managedSchemas.createVersion(namespace, slug, {
+    document,
+    version,
+    force: data.force
+  }) : await client.managedSchemas.create(namespace, {
+    title: title || "Untitled",
+    version,
+    slug,
+    isPrivate: data.private,
+    document
+  });
+  if (publishRes.error)
+    return output.error().title(publishRes.message).exit("error");
+  const schema = registry(namespace).schemas(slug);
+  const schemaUrl = dashboardUrl(
+    RegistryAsset.Schemas,
+    matchingSchema?.uid ?? publishRes.data.uid
+  );
+  logger.update("loader", 0, {
+    content: `Successfully published v${version} for ${slug}.`
+  }).line().line(`${as.green("\u279C")} ${as.white.bold("View in dashboard:")}`).line(as.cyan(schemaUrl)).line().line(`${as.green("\u279C")} ${as.white.bold("Registry Preview:")}`).line(as.cyan(registryUrl(schema.url({ version })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry YAML:")}`).line(as.cyan(registryUrl(schema.url({ version, format: "yaml" })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry JSON:")}`).line(as.cyan(registryUrl(schema.url({ version, format: "json" })))).print();
+}
+export {
+  publishAction
+};

package/chunks/update.action-6QEFP7NA.js

@@ -0,0 +1,95 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/update.action.ts
+import { select } from "@clack/prompts";
+async function updateAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional(),
+    title: external_exports.string().max(50).optional(),
+    description: external_exports.string().optional(),
+    isPrivate: external_exports.boolean().optional()
+  }).safeParse(opts);
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const client = await apiService();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your schema. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const schemas = await client.managedSchemas.getSchemas(namespace);
+  if (schemas.error) return output.error().title(schemas.message).exit("error");
+  const schemaSlug = schemas.data.find((schema) => schema.slug === data.slug)?.slug || await select({
+    message: "Please select a schema to update",
+    options: schemas.data.map((schema) => ({
+      value: schema.slug,
+      label: schema.slug
+    }))
+  });
+  if (!schemaSlug) {
+    return output.error().title("No schema found").message("Please provide a valid schema slug").exit("error");
+  }
+  const logger = output.info().loader("Updating the schema");
+  const response = await client.managedSchemas.update(namespace, schemaSlug, {
+    title: data.title,
+    description: data.description,
+    isPrivate: data.isPrivate
+  });
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Schema updated successfully!" }).exit("success");
+}
+export {
+  updateAction
+};