shop-cli 0.1.1

package/dist/cli/verbs/metaobject-definition-tools.js

@@ -0,0 +1,83 @@
+"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 metaobject_definition_tools_exports = {};
+__export(metaobject_definition_tools_exports, {
+  runMetaobjectDefinitionTools: () => runMetaobjectDefinitionTools
+});
+module.exports = __toCommonJS(metaobject_definition_tools_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_userErrors = require("../userErrors");
+const metaobjectDefinitionSelection = {
+  id: true,
+  name: true,
+  type: true
+};
+const runMetaobjectDefinitionTools = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metaobject-definition-tools <verb> [flags]",
+        "",
+        "Verbs:",
+        "  standard-enable"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "standard-enable") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" } } });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const type = args.type ?? input.type;
+    if (!type) throw new import_errors.CliError("Missing --type", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      standardMetaobjectDefinitionEnable: {
+        __args: { type },
+        metaobjectDefinition: metaobjectDefinitionSelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.standardMetaobjectDefinitionEnable,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.standardMetaobjectDefinitionEnable?.metaobjectDefinition?.id ?? "");
+    (0, import_output.printJson)(result.standardMetaobjectDefinitionEnable, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metaobject-definition-tools: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetaobjectDefinitionTools
+});
+//# sourceMappingURL=metaobject-definition-tools.js.map

package/dist/cli/verbs/metaobject-definitions.d.ts

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

package/dist/cli/verbs/metaobject-definitions.js

@@ -0,0 +1,176 @@
+"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 metaobject_definitions_exports = {};
+__export(metaobject_definitions_exports, {
+  runMetaobjectDefinitions: () => runMetaobjectDefinitions
+});
+module.exports = __toCommonJS(metaobject_definitions_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 metaobjectDefinitionSummarySelection = {
+  id: true,
+  name: true,
+  type: true
+};
+const getMetaobjectDefinitionSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return metaobjectDefinitionSummarySelection;
+};
+const runMetaobjectDefinitions = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metaobject-definitions <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|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, "MetaobjectDefinition");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "metaobject-definitions",
+      view: ctx.view,
+      baseSelection: getMetaobjectDefinitionSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { metaobjectDefinition: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.metaobjectDefinition, 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 reverse = args.reverse;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "metaobject-definitions",
+      view: ctx.view,
+      baseSelection: getMetaobjectDefinitionSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      metaobjectDefinitions: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.metaobjectDefinitions,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("metaobject-definitions", { first, 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 result = await (0, import_router.runMutation)(ctx, {
+      metaobjectDefinitionCreate: {
+        __args: { definition: built.input },
+        metaobjectDefinition: metaobjectDefinitionSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectDefinitionCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectDefinitionCreate?.metaobjectDefinition?.id ?? "");
+    (0, import_output.printJson)(result.metaobjectDefinitionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "MetaobjectDefinition");
+    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, {
+      metaobjectDefinitionUpdate: {
+        __args: { id, definition: built.input },
+        metaobjectDefinition: metaobjectDefinitionSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectDefinitionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectDefinitionUpdate?.metaobjectDefinition?.id ?? "");
+    (0, import_output.printJson)(result.metaobjectDefinitionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "MetaobjectDefinition");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      metaobjectDefinitionDelete: {
+        __args: { id },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectDefinitionDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectDefinitionDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.metaobjectDefinitionDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metaobject-definitions: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetaobjectDefinitions
+});
+//# sourceMappingURL=metaobject-definitions.js.map

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

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

package/dist/cli/verbs/metaobjects.js

@@ -0,0 +1,306 @@
+"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 metaobjects_exports = {};
+__export(metaobjects_exports, {
+  runMetaobjects: () => runMetaobjects
+});
+module.exports = __toCommonJS(metaobjects_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 metaobjectSummarySelection = {
+  id: true,
+  displayName: true,
+  handle: true,
+  updatedAt: true,
+  createdAt: true
+};
+const metaobjectFullSelection = {
+  ...metaobjectSummarySelection
+};
+const getMetaobjectSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return metaobjectFullSelection;
+  if (view === "raw") return {};
+  return metaobjectSummarySelection;
+};
+const metaobjectDefinitionSummarySelection = {
+  id: true,
+  name: true,
+  type: true
+};
+const runMetaobjects = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metaobjects <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete",
+        "  by-handle|definition-by-type|upsert|bulk-delete",
+        "",
+        "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 === "by-handle") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" }, handle: { type: "string" } } });
+    const type = args.type;
+    const handle = args.handle;
+    if (!type) throw new import_errors.CliError("Missing --type", 2);
+    if (!handle) throw new import_errors.CliError("Missing --handle", 2);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "metaobjects",
+      view: ctx.view,
+      baseSelection: getMetaobjectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      metaobjectByHandle: {
+        __args: { handle: { type, handle } },
+        ...selection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.metaobjectByHandle, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "definition-by-type") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" } } });
+    const type = args.type;
+    if (!type) throw new import_errors.CliError("Missing --type", 2);
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "MetaobjectDefinition",
+      view: ctx.view,
+      baseSelection: metaobjectDefinitionSummarySelection,
+      select: args.select,
+      selection: args.selection,
+      ensureId: true
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      metaobjectDefinitionByType: {
+        __args: { type },
+        ...selection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.metaobjectDefinitionByType, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "upsert") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" }, handle: { type: "string" } } });
+    const type = args.type;
+    const handle = args.handle;
+    if (!type) throw new import_errors.CliError("Missing --type", 2);
+    if (!handle) throw new import_errors.CliError("Missing --handle", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const metaobject = built.used ? built.input : {};
+    const selection = (0, import_select.resolveSelection)({
+      resource: "metaobjects",
+      view: ctx.view,
+      baseSelection: getMetaobjectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      metaobjectUpsert: {
+        __args: { handle: { type, handle }, metaobject },
+        metaobject: selection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectUpsert, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectUpsert?.metaobject?.id ?? "");
+    (0, import_output.printJson)(result.metaobjectUpsert, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" } } });
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const type = args.type;
+    const ids = args.ids !== void 0 ? (0, import_shared.parseIds)(args.ids, "Metaobject") : void 0;
+    if (!type && (!ids || ids.length === 0)) throw new import_errors.CliError("Missing --type or --ids", 2);
+    const where = { ...type ? { type } : {}, ...ids && ids.length ? { ids } : {} };
+    const requestedCount = ids && ids.length > 0 ? ids.length : type ? (await (0, import_router.runQuery)(ctx, { metaobjectDefinitionByType: { __args: { type }, metaobjectsCount: true } }))?.metaobjectDefinitionByType?.metaobjectsCount ?? null : null;
+    const result = await (0, import_router.runMutation)(ctx, {
+      metaobjectBulkDelete: {
+        __args: { where },
+        job: { id: true, done: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectBulkDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectBulkDelete?.job?.id ?? "");
+    (0, import_output.printJson)(
+      {
+        job: result.metaobjectBulkDelete?.job ?? null,
+        where,
+        requestedCount,
+        userErrors: result.metaobjectBulkDelete?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Metaobject");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "metaobjects",
+      view: ctx.view,
+      baseSelection: getMetaobjectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { metaobject: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.metaobject, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { type: { type: "string" } } });
+    const type = args.type;
+    if (!type) throw new import_errors.CliError("Missing --type", 2);
+    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: "metaobjects",
+      view: ctx.view,
+      baseSelection: getMetaobjectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      metaobjects: {
+        __args: { type, first, after, query, reverse, ...sortKey ? { sortKey } : {} },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.metaobjects,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "metaobjects",
+        { first, query, sort: sortKey, reverse },
+        [{ flag: "--type", value: type }]
+      )
+    });
+    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, {
+      metaobjectCreate: {
+        __args: { metaobject: built.input },
+        metaobject: metaobjectSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectCreate?.metaobject?.id ?? "");
+    (0, import_output.printJson)(result.metaobjectCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Metaobject");
+    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, {
+      metaobjectUpdate: {
+        __args: { id, metaobject: built.input },
+        metaobject: metaobjectSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectUpdate?.metaobject?.id ?? "");
+    (0, import_output.printJson)(result.metaobjectUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Metaobject");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      metaobjectDelete: {
+        __args: { id },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metaobjectDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metaobjectDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.metaobjectDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metaobjects: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetaobjects
+});
+//# sourceMappingURL=metaobjects.js.map

package/dist/cli/verbs/mobile-platform-applications.d.ts

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