shop-cli 0.1.1

package/dist/cli/verbs/catalogs.js

@@ -0,0 +1,267 @@
+"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 catalogs_exports = {};
+__export(catalogs_exports, {
+  runCatalogs: () => runCatalogs
+});
+module.exports = __toCommonJS(catalogs_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 catalogSummarySelection = {
+  id: true,
+  title: true,
+  status: true
+};
+const getCatalogSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return catalogSummarySelection;
+};
+const runCatalogs = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop catalogs <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|count|operations|context-update|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 === "operations") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ResourceOperation",
+      view: ctx.view,
+      baseSelection: {
+        id: true,
+        status: true,
+        processedRowCount: true,
+        rowCount: { count: true, exceedsMax: true },
+        __typename: true
+      },
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { catalogOperations: selection });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.catalogOperations, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { limit: { type: "string" } } });
+    const query = args.query;
+    const type = args.type;
+    const limitRaw = args.limit;
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const result = await (0, import_router.runQuery)(ctx, {
+      catalogsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...type ? { type } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.catalogsCount?.count ?? "");
+    (0, import_output.printJson)(result.catalogsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "context-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "catalog-id": { type: "string" },
+        "contexts-to-add": { type: "string" },
+        "contexts-to-remove": { type: "string" }
+      }
+    });
+    const catalogId = (0, import_shared.requireId)(args["catalog-id"], "Catalog", "--catalog-id");
+    const contextsToAdd = args["contexts-to-add"] ? (0, import_shared.parseJsonArg)(args["contexts-to-add"], "--contexts-to-add") : void 0;
+    const contextsToRemove = args["contexts-to-remove"] ? (0, import_shared.parseJsonArg)(args["contexts-to-remove"], "--contexts-to-remove") : void 0;
+    if (contextsToAdd === void 0 && contextsToRemove === void 0) {
+      throw new import_errors.CliError("Missing --contexts-to-add and/or --contexts-to-remove", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      catalogContextUpdate: {
+        __args: {
+          catalogId,
+          ...contextsToAdd !== void 0 ? { contextsToAdd } : {},
+          ...contextsToRemove !== void 0 ? { contextsToRemove } : {}
+        },
+        catalog: catalogSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.catalogContextUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.catalogContextUpdate?.catalog?.id ?? "");
+    (0, import_output.printJson)(result.catalogContextUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Catalog");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "catalogs",
+      view: ctx.view,
+      baseSelection: getCatalogSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { catalog: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.catalog, 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: "catalogs",
+      view: ctx.view,
+      baseSelection: getCatalogSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      catalogs: {
+        __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.catalogs,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "catalogs",
+        { first, query, sort: sortKey, reverse },
+        type ? [{ flag: "--type", value: type }] : void 0
+      )
+    });
+    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, {
+      catalogCreate: {
+        __args: { input: built.input },
+        catalog: catalogSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.catalogCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.catalogCreate?.catalog?.id ?? "");
+    (0, import_output.printJson)(result.catalogCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Catalog");
+    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, {
+      catalogUpdate: {
+        __args: { id, input: built.input },
+        catalog: catalogSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.catalogUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.catalogUpdate?.catalog?.id ?? "");
+    (0, import_output.printJson)(result.catalogUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Catalog");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const extra = (0, import_input.buildInput)({
+      inputArg: void 0,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      catalogDelete: {
+        __args: { id, ...extra.used ? extra.input : {} },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.catalogDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.catalogDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.catalogDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for catalogs: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCatalogs
+});
+//# sourceMappingURL=catalogs.js.map

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

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

package/dist/cli/verbs/channels.js

@@ -0,0 +1,120 @@
+"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 channels_exports = {};
+__export(channels_exports, {
+  runChannels: () => runChannels
+});
+module.exports = __toCommonJS(channels_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_shared = require("./_shared");
+const channelSummarySelection = {
+  id: true,
+  name: true,
+  handle: true,
+  overviewPath: true
+};
+const channelFullSelection = {
+  ...channelSummarySelection,
+  supportsFuturePublishing: true
+};
+const getChannelSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return channelFullSelection;
+  if (view === "raw") return {};
+  return channelSummarySelection;
+};
+const runChannels = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop channels <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list",
+        "",
+        "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 === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Channel");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "channels",
+      view: ctx.view,
+      baseSelection: getChannelSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { channel: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.channel, 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: "channels",
+      view: ctx.view,
+      baseSelection: getChannelSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      channels: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.channels,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("channels", { first, reverse })
+    });
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for channels: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runChannels
+});
+//# sourceMappingURL=channels.js.map

package/dist/cli/verbs/checkout-branding.d.ts

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

package/dist/cli/verbs/checkout-branding.js

@@ -0,0 +1,144 @@
+"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 checkout_branding_exports = {};
+__export(checkout_branding_exports, {
+  runCheckoutBranding: () => runCheckoutBranding
+});
+module.exports = __toCommonJS(checkout_branding_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");
+var import_shared = require("./_shared");
+const checkoutBrandingSelection = {
+  customizations: {
+    checkbox: { cornerRadius: true },
+    control: { border: true, color: true, cornerRadius: true, labelPosition: true },
+    favicon: { image: { id: true, url: true } },
+    global: { cornerRadius: true, typography: { letterCase: true, kerning: true } },
+    header: {
+      alignment: true,
+      position: true,
+      logo: { image: { id: true, url: true }, maxWidth: true, visibility: true },
+      banner: { image: { id: true, url: true } }
+    },
+    main: { backgroundImage: { image: { id: true, url: true } } },
+    orderSummary: { backgroundImage: { image: { id: true, url: true } } },
+    primaryButton: {
+      background: true,
+      blockPadding: true,
+      border: true,
+      cornerRadius: true,
+      typography: { font: true, size: true, weight: true, letterCase: true, kerning: true }
+    },
+    secondaryButton: {
+      background: true,
+      border: true,
+      cornerRadius: true,
+      typography: { font: true, size: true, weight: true, letterCase: true, kerning: true }
+    },
+    textField: {
+      border: true,
+      typography: { font: true, size: true, weight: true, letterCase: true, kerning: true }
+    }
+  },
+  designSystem: {
+    colors: {
+      global: {
+        accent: true,
+        brand: true,
+        critical: true,
+        decorative: true,
+        info: true,
+        success: true,
+        warning: true
+      },
+      schemes: {
+        scheme1: {
+          base: { accent: true, background: true, border: true, decorative: true, icon: true, text: true },
+          control: { accent: true, background: true, border: true, decorative: true, icon: true, text: true },
+          primaryButton: { accent: true, background: true, border: true, decorative: true, icon: true, text: true },
+          secondaryButton: { accent: true, background: true, border: true, decorative: true, icon: true, text: true }
+        }
+      }
+    },
+    cornerRadius: { base: true, small: true, large: true },
+    typography: {
+      primary: { name: true, loadingStrategy: true, base: { sources: true, weight: true }, bold: { sources: true, weight: true } },
+      secondary: { name: true, loadingStrategy: true, base: { sources: true, weight: true }, bold: { sources: true, weight: true } },
+      size: { base: true, ratio: true }
+    }
+  }
+};
+const runCheckoutBranding = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop checkout-branding <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|upsert"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "profile-id": { type: "string" } } });
+    const profileId = (0, import_shared.requireId)(args["profile-id"], "CheckoutProfile", "--profile-id");
+    const result = await (0, import_router.runQuery)(ctx, {
+      checkoutBranding: { __args: { checkoutProfileId: profileId }, ...checkoutBrandingSelection }
+    });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result.checkoutBranding, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "upsert") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "profile-id": { type: "string" } } });
+    const profileId = (0, import_shared.requireId)(args["profile-id"], "CheckoutProfile", "--profile-id");
+    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, {
+      checkoutBrandingUpsert: {
+        __args: { checkoutProfileId: profileId, checkoutBrandingInput: built.input },
+        checkoutBranding: checkoutBrandingSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.checkoutBrandingUpsert, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.checkoutBrandingUpsert, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for checkout-branding: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCheckoutBranding
+});
+//# sourceMappingURL=checkout-branding.js.map

package/dist/cli/verbs/checkout-profiles.d.ts

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

package/dist/cli/verbs/checkout-profiles.js

@@ -0,0 +1,124 @@
+"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 checkout_profiles_exports = {};
+__export(checkout_profiles_exports, {
+  runCheckoutProfiles: () => runCheckoutProfiles
+});
+module.exports = __toCommonJS(checkout_profiles_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_shared = require("./_shared");
+const checkoutProfileSummarySelection = {
+  id: true,
+  name: true,
+  isPublished: true,
+  updatedAt: true
+};
+const checkoutProfileFullSelection = {
+  ...checkoutProfileSummarySelection,
+  createdAt: true,
+  editedAt: true,
+  typOspPagesActive: true
+};
+const getCheckoutProfileSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return checkoutProfileFullSelection;
+  if (view === "raw") return {};
+  return checkoutProfileSummarySelection;
+};
+const runCheckoutProfiles = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop checkout-profiles <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list",
+        "",
+        "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 === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "CheckoutProfile");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "checkout-profiles",
+      view: ctx.view,
+      baseSelection: getCheckoutProfileSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { checkoutProfile: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.checkoutProfile, 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: "checkout-profiles",
+      view: ctx.view,
+      baseSelection: getCheckoutProfileSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      checkoutProfiles: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.checkoutProfiles,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("checkout-profiles", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for checkout-profiles: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCheckoutProfiles
+});
+//# sourceMappingURL=checkout-profiles.js.map

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

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