shop-cli 0.1.0

package/dist/cli/verbs/markets.js

@@ -0,0 +1,324 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markets_exports = {};
+__export(markets_exports, {
+  runMarkets: () => runMarkets
+});
+module.exports = __toCommonJS(markets_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const marketSummarySelection = {
+  id: true,
+  name: true,
+  handle: true,
+  status: true,
+  type: true
+};
+const getMarketSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return marketSummarySelection;
+};
+const requireCountryCode = (value) => {
+  if (typeof value !== "string" || !value.trim()) throw new import_errors.CliError("Missing --country-code", 2);
+  return value.trim().toUpperCase();
+};
+const runMarkets = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop markets <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete",
+        "  by-geography|primary|resolved-values",
+        "  currency-settings-update|regions-create|regions-delete|region-delete",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Market");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "markets",
+      view: ctx.view,
+      baseSelection: getMarketSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { market: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.market, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const query = args.query;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const type = args.type;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "markets",
+      view: ctx.view,
+      baseSelection: getMarketSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      markets: {
+        __args: { first, after, query, reverse, sortKey, ...type ? { type } : {} },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.markets,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "markets",
+        { first, query, sort: sortKey, reverse },
+        type ? [{ flag: "--type", value: type }] : void 0
+      )
+    });
+    return;
+  }
+  if (verb === "by-geography") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "country-code": { type: "string" } } });
+    const countryCode = requireCountryCode(args["country-code"]);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "markets",
+      view: ctx.view,
+      baseSelection: getMarketSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      marketByGeography: { __args: { countryCode }, ...selection }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.marketByGeography, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "primary") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const selection = (0, import_select.resolveSelection)({
+      resource: "markets",
+      view: ctx.view,
+      baseSelection: getMarketSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { primaryMarket: selection });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.primaryMarket, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "resolved-values") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "country-code": { type: "string" } } });
+    const countryCode = requireCountryCode(args["country-code"]);
+    const result = await (0, import_router.runQuery)(ctx, {
+      marketsResolvedValues: {
+        __args: { buyerSignal: { countryCode } },
+        currencyCode: true,
+        priceInclusivity: {
+          dutiesIncluded: true,
+          taxesIncluded: true
+        },
+        catalogs: { __args: { first: 5 }, nodes: { id: true, title: true } },
+        webPresences: { __args: { first: 5 }, nodes: { id: true, domain: { host: true }, subfolderSuffix: true } }
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.marketsResolvedValues, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketCreate: {
+        __args: { input: built.input },
+        market: marketSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.marketCreate?.market?.id ?? "");
+    (0, import_output.printJson)(result.marketCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "currency-settings-update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const marketId = (0, import_shared.requireId)(args.id, "Market");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketCurrencySettingsUpdate: {
+        __args: { marketId, input: built.input },
+        market: marketSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.marketCurrencySettingsUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.marketCurrencySettingsUpdate?.market?.id ?? "");
+    (0, import_output.printJson)(result.marketCurrencySettingsUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "regions-create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "country-codes": { type: "string" } } });
+    const marketId = (0, import_shared.requireId)(args.id, "Market");
+    const countryCodes = (0, import_shared.parseCsv)(args["country-codes"], "--country-codes");
+    const regions = countryCodes.map((countryCode) => ({ countryCode: countryCode.toUpperCase() }));
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketRegionsCreate: {
+        __args: { marketId, regions },
+        market: marketSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketRegionsCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.marketRegionsCreate?.market?.id ?? "");
+    (0, import_output.printJson)(result.marketRegionsCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "regions-delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const ids = (0, import_shared.parseIds)(args.ids, "MarketRegionCountry");
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketRegionsDelete: {
+        __args: { ids },
+        deletedIds: true,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketRegionsDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.marketRegionsDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "region-delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "MarketRegionCountry");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketRegionDelete: {
+        __args: { id },
+        deletedId: true,
+        market: marketSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketRegionDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.marketRegionDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.marketRegionDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Market");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketUpdate: {
+        __args: { id, input: built.input },
+        market: marketSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.marketUpdate?.market?.id ?? "");
+    (0, import_output.printJson)(result.marketUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Market");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketDelete: {
+        __args: { id },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.marketDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.marketDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for markets: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMarkets
+});
+//# sourceMappingURL=markets.js.map

package/dist/cli/verbs/menus.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runMenus: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;

package/dist/cli/verbs/menus.js

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var menus_exports = {};
+__export(menus_exports, {
+  runMenus: () => runMenus
+});
+module.exports = __toCommonJS(menus_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const menuSummarySelection = {
+  id: true,
+  title: true,
+  handle: true,
+  isDefault: true
+};
+const menuFullSelection = {
+  ...menuSummarySelection
+};
+const getMenuSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return menuFullSelection;
+  if (view === "raw") return {};
+  return menuSummarySelection;
+};
+const requireMenuArgs = (value, required) => {
+  if (value === null || typeof value !== "object") throw new import_errors.CliError("Menu input must be an object", 2);
+  for (const key of required) {
+    if (value[key] === void 0) throw new import_errors.CliError(`Missing ${key} in --input/--set`, 2);
+  }
+  return value;
+};
+const runMenus = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop menus <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete",
+        "  create-basic|update-basic",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "create-basic") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { title: { type: "string" }, handle: { type: "string" }, items: { type: "string" } }
+    });
+    const title = args.title;
+    const handle = args.handle;
+    const itemsRaw = args.items;
+    if (!title) throw new import_errors.CliError("Missing --title", 2);
+    if (!handle) throw new import_errors.CliError("Missing --handle", 2);
+    if (!itemsRaw) throw new import_errors.CliError("Missing --items", 2);
+    const items = (0, import_shared.parseJsonArg)(itemsRaw, "--items");
+    if (!Array.isArray(items)) throw new import_errors.CliError("--items must be a JSON array", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      menuCreate: {
+        __args: { title, handle, items },
+        menu: menuSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.menuCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.menuCreate?.menu?.id ?? "");
+    (0, import_output.printJson)(result.menuCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update-basic") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { title: { type: "string" }, handle: { type: "string" }, items: { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "Menu");
+    const title = args.title;
+    const handle = args.handle;
+    const itemsRaw = args.items;
+    if (!title) throw new import_errors.CliError("Missing --title", 2);
+    if (!itemsRaw) throw new import_errors.CliError("Missing --items", 2);
+    const items = (0, import_shared.parseJsonArg)(itemsRaw, "--items");
+    if (!Array.isArray(items)) throw new import_errors.CliError("--items must be a JSON array", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      menuUpdate: {
+        __args: { id, title, ...handle ? { handle } : {}, items },
+        menu: menuSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.menuUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.menuUpdate?.menu?.id ?? "");
+    (0, import_output.printJson)(result.menuUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Menu");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "menus",
+      view: ctx.view,
+      baseSelection: getMenuSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { menu: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.menu, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const query = args.query;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "menus",
+      view: ctx.view,
+      baseSelection: getMenuSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      menus: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.menus,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("menus", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const input = requireMenuArgs(built.input, ["title", "handle", "items"]);
+    const result = await (0, import_router.runMutation)(ctx, {
+      menuCreate: {
+        __args: { title: input.title, handle: input.handle, items: input.items },
+        menu: menuSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.menuCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.menuCreate?.menu?.id ?? "");
+    (0, import_output.printJson)(result.menuCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Menu");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const input = requireMenuArgs(built.input, ["title", "items"]);
+    const mutationArgs = {
+      id,
+      title: input.title,
+      items: input.items,
+      ...input.handle === void 0 ? {} : { handle: input.handle }
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      menuUpdate: {
+        __args: mutationArgs,
+        menu: menuSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.menuUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.menuUpdate?.menu?.id ?? "");
+    (0, import_output.printJson)(result.menuUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Menu");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      menuDelete: {
+        __args: { id },
+        deletedMenuId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.menuDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.menuDelete?.deletedMenuId ?? "");
+    (0, import_output.printJson)(result.menuDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for menus: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMenus
+});
+//# sourceMappingURL=menus.js.map

package/dist/cli/verbs/metafield-definition-tools.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runMetafieldDefinitionTools: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;