shop-cli 0.1.1

package/dist/cli/verbs/disputes.js

@@ -0,0 +1,154 @@
+"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 disputes_exports = {};
+__export(disputes_exports, {
+  runDisputes: () => runDisputes
+});
+module.exports = __toCommonJS(disputes_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 disputeSummarySelection = {
+  id: true,
+  status: true,
+  type: true,
+  initiatedAt: true,
+  evidenceDueBy: true,
+  amount: { amount: true, currencyCode: true },
+  order: { id: true, name: true }
+};
+const disputeEvidenceSummarySelection = {
+  id: true,
+  customerEmailAddress: true,
+  dispute: { id: true, status: true, initiatedAt: true }
+};
+const getDisputeSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return disputeSummarySelection;
+};
+const getEvidenceSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return disputeEvidenceSummarySelection;
+};
+const runDisputes = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop disputes <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list",
+        "  evidence get|evidence update"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "ShopifyPaymentsDispute");
+    const selection = (0, import_select.resolveSelection)({
+      view: ctx.view,
+      baseSelection: getDisputeSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { dispute: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.dispute, 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)({
+      view: ctx.view,
+      baseSelection: getDisputeSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      disputes: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({ connection: result.disputes, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "evidence get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "ShopifyPaymentsDisputeEvidence");
+    const selection = (0, import_select.resolveSelection)({
+      view: ctx.view,
+      baseSelection: getEvidenceSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { disputeEvidence: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.disputeEvidence, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "evidence update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "ShopifyPaymentsDisputeEvidence");
+    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, {
+      disputeEvidenceUpdate: {
+        __args: { id, input: built.input },
+        disputeEvidence: { id: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.disputeEvidenceUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.disputeEvidenceUpdate?.disputeEvidence?.id ?? "");
+    (0, import_output.printJson)(result.disputeEvidenceUpdate, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for disputes: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runDisputes
+});
+//# sourceMappingURL=disputes.js.map

package/dist/cli/verbs/draft-orders.d.ts

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

package/dist/cli/verbs/draft-orders.js

@@ -0,0 +1,475 @@
+"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 draft_orders_exports = {};
+__export(draft_orders_exports, {
+  runDraftOrders: () => runDraftOrders
+});
+module.exports = __toCommonJS(draft_orders_exports);
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+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 draftOrderSummarySelection = {
+  id: true,
+  status: true,
+  email: true,
+  createdAt: true,
+  updatedAt: true,
+  tags: true
+};
+const draftOrderFullSelection = {
+  ...draftOrderSummarySelection,
+  completedAt: true,
+  invoiceSentAt: true,
+  currencyCode: true
+};
+const calculatedDraftOrderSummarySelection = {
+  currencyCode: true,
+  presentmentCurrencyCode: true,
+  taxesIncluded: true,
+  discountCodes: true,
+  appliedDiscount: {
+    title: true,
+    description: true,
+    value: true,
+    valueType: true,
+    amountSet: { shopMoney: { amount: true, currencyCode: true } }
+  },
+  lineItemsSubtotalPrice: { shopMoney: { amount: true, currencyCode: true } },
+  subtotalPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+  totalLineItemsPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+  totalDiscountsSet: { shopMoney: { amount: true, currencyCode: true } },
+  totalShippingPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+  totalTaxSet: { shopMoney: { amount: true, currencyCode: true } },
+  totalPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+  shippingLine: {
+    title: true,
+    originalPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+    discountedPriceSet: { shopMoney: { amount: true, currencyCode: true } }
+  },
+  taxLines: {
+    title: true,
+    ratePercentage: true,
+    priceSet: { shopMoney: { amount: true, currencyCode: true } }
+  },
+  lineItems: {
+    uuid: true,
+    title: true,
+    name: true,
+    quantity: true,
+    sku: true,
+    requiresShipping: true,
+    taxable: true,
+    isGiftCard: true,
+    originalUnitPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+    approximateDiscountedUnitPriceSet: { shopMoney: { amount: true, currencyCode: true } },
+    originalTotalSet: { shopMoney: { amount: true, currencyCode: true } },
+    discountedTotalSet: { shopMoney: { amount: true, currencyCode: true } },
+    totalDiscountSet: { shopMoney: { amount: true, currencyCode: true } },
+    variantTitle: true,
+    variant: { id: true, title: true },
+    product: { id: true, title: true }
+  }
+};
+const getDraftOrderSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return draftOrderFullSelection;
+  if (view === "raw") return {};
+  return draftOrderSummarySelection;
+};
+const runDraftOrders = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop draft-orders <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list|count",
+        "  create|update|delete|duplicate|calculate|complete",
+        "  create-from-order",
+        "  preview-invoice|send-invoice",
+        "  bulk-add-tags|bulk-remove-tags|bulk-delete",
+        "  saved-searches|tags|delivery-options",
+        "",
+        "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, "DraftOrder");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "draft-orders",
+      view: ctx.view,
+      baseSelection: getDraftOrderSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { draftOrder: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.draftOrder, 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: "draft-orders",
+      view: ctx.view,
+      baseSelection: getDraftOrderSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      draftOrders: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.draftOrders,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("draft-orders", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, { draftOrdersCount: { __args: { query }, count: true, precision: true } });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.draftOrdersCount?.count ?? "");
+    (0, import_output.printJson)(result.draftOrdersCount, 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, {
+      draftOrderCreate: {
+        __args: { input: built.input },
+        draftOrder: draftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderCreate?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrder");
+    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, {
+      draftOrderUpdate: {
+        __args: { id, input: built.input },
+        draftOrder: draftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderUpdate?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrder");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderDelete: {
+        __args: { input: { id } },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.draftOrderDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "duplicate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrder");
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderDuplicate: {
+        __args: { id },
+        draftOrder: draftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderDuplicate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderDuplicate?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderDuplicate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "calculate") {
+    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, {
+      draftOrderCalculate: {
+        __args: { input: built.input },
+        calculatedDraftOrder: calculatedDraftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderCalculate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.draftOrderCalculate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "complete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrder");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderComplete: {
+        __args: { id, ...built.used ? built.input : {} },
+        draftOrder: draftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderComplete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderComplete?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderComplete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create-from-order") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "order-id": { type: "string" } } });
+    const orderId = args["order-id"];
+    if (!orderId) throw new import_errors.CliError("Missing --order-id", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderCreateFromOrder: {
+        __args: { orderId: (0, import_gid.coerceGid)(orderId, "Order") },
+        draftOrder: draftOrderSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderCreateFromOrder, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderCreateFromOrder?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderCreateFromOrder, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "preview-invoice" || verb === "send-invoice") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrder");
+    const email = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (verb === "preview-invoice") {
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        draftOrderInvoicePreview: {
+          __args: { id, ...email.used ? { email: email.input } : {} },
+          previewHtml: true,
+          previewSubject: true,
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.draftOrderInvoicePreview, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return console.log(result2.draftOrderInvoicePreview?.previewHtml ?? "");
+      (0, import_output.printJson)(result2.draftOrderInvoicePreview, ctx.format !== "raw");
+      return;
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderInvoiceSend: {
+        __args: { id, ...email.used ? { email: email.input } : {} },
+        draftOrder: { id: true, status: true, updatedAt: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderInvoiceSend, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderInvoiceSend?.draftOrder?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderInvoiceSend, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-add-tags" || verb === "bulk-remove-tags") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { ids: { type: "string", multiple: true } }
+    });
+    const ids = (0, import_shared.parseIds)(args.ids, "DraftOrder");
+    const tags = (0, import_shared.parseCsv)(args.tags, "--tags");
+    const mutationField = verb === "bulk-add-tags" ? "draftOrderBulkAddTags" : "draftOrderBulkRemoveTags";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutationField]: {
+        __args: { ids, tags },
+        job: { id: true, done: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutationField];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.job?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { ids: { type: "string", multiple: true } }
+    });
+    if (!args.yes) throw new import_errors.CliError("Refusing to bulk-delete without --yes", 2);
+    const ids = (0, import_shared.parseIds)(args.ids, "DraftOrder");
+    const result = await (0, import_router.runMutation)(ctx, {
+      draftOrderBulkDelete: {
+        __args: { ids },
+        job: { id: true, done: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.draftOrderBulkDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.draftOrderBulkDelete?.job?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderBulkDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "saved-searches") {
+    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 result = await (0, import_router.runQuery)(ctx, {
+      draftOrderSavedSearches: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: { id: true, name: true, query: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.draftOrderSavedSearches,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: { base: "shop draft-orders saved-searches", first, reverse }
+    });
+    return;
+  }
+  if (verb === "tags") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "DraftOrderTag");
+    const result = await (0, import_router.runQuery)(ctx, {
+      draftOrderTag: { __args: { id }, id: true, title: true, handle: true }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.draftOrderTag?.id ?? "");
+    (0, import_output.printJson)(result.draftOrderTag, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delivery-options") {
+    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.runQuery)(ctx, {
+      draftOrderAvailableDeliveryOptions: {
+        __args: { input: built.input },
+        availableShippingRates: {
+          title: true,
+          handle: true,
+          code: true,
+          source: true,
+          price: { amount: true, currencyCode: true }
+        },
+        availableLocalDeliveryRates: {
+          title: true,
+          handle: true,
+          code: true,
+          source: true,
+          price: { amount: true, currencyCode: true }
+        },
+        availableLocalPickupOptions: {
+          title: true,
+          handle: true,
+          code: true,
+          instructions: true,
+          locationId: true,
+          source: true
+        },
+        pageInfo: { hasNextPage: true, endCursor: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result.draftOrderAvailableDeliveryOptions, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for draft-orders: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runDraftOrders
+});
+//# sourceMappingURL=draft-orders.js.map

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

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