shop-cli 0.1.1

package/dist/cli/verbs/inventory.js

@@ -0,0 +1,557 @@
+"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 inventory_exports = {};
+__export(inventory_exports, {
+  runInventory: () => runInventory
+});
+module.exports = __toCommonJS(inventory_exports);
+var import_node_crypto = require("node:crypto");
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+var import_router = require("../router");
+var import_userErrors = require("../userErrors");
+var import_resolveInventoryItemId = require("../workflows/inventory/resolveInventoryItemId");
+var import_output = require("../output");
+var import_shared = require("./_shared");
+const inventoryAdjustmentGroupSelection = ({
+  inventoryItemId,
+  locationIds
+}) => ({
+  id: true,
+  reason: true,
+  createdAt: true,
+  referenceDocumentUri: true,
+  changes: {
+    __args: {
+      inventoryItemIds: [inventoryItemId],
+      locationIds,
+      quantityNames: ["available"]
+    },
+    name: true,
+    delta: true,
+    quantityAfterChange: true,
+    item: { id: true },
+    location: { id: true, name: true }
+  }
+});
+const runInventory = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop inventory <verb> [flags]",
+        "",
+        "Verbs:",
+        "  list|set|adjust|move",
+        "  properties|level",
+        "  activate|deactivate|bulk-toggle-activation",
+        "  set-on-hand-quantities|set-scheduled-changes|transfer-set-items",
+        "",
+        "Notes:",
+        "  - set/adjust support --inventory-item-id or --variant-id",
+        "  - move requires --from-location-id, --to-location-id, and --reference-document-uri"
+      ].join("\n")
+    );
+    return;
+  }
+  const parseOptionalInt = (value, flag) => {
+    if (value === void 0) return void 0;
+    return (0, import_shared.parseIntFlag)(flag, value);
+  };
+  const requireInventoryLevelId = (value) => {
+    if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --inventory-level-id", 2);
+    return (0, import_gid.coerceGid)(value, "InventoryLevel");
+  };
+  const requireInventoryTransferId = (value) => {
+    if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --transfer-id", 2);
+    return (0, import_gid.coerceGid)(value, "InventoryTransfer");
+  };
+  const inventoryLevelSelection = {
+    id: true,
+    updatedAt: true,
+    item: { id: true, sku: true, tracked: true },
+    location: { id: true, name: true },
+    quantities: {
+      __args: { names: ["available", "on_hand"] },
+      name: true,
+      quantity: true,
+      updatedAt: true
+    }
+  };
+  if (verb === "properties") {
+    const result = await (0, import_router.runQuery)(ctx, {
+      inventoryProperties: {
+        quantityNames: {
+          name: true,
+          displayName: true,
+          isInUse: true,
+          belongsTo: true,
+          comprises: true
+        }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result.inventoryProperties, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "level") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = requireInventoryLevelId(args2.id);
+    const result = await (0, import_router.runQuery)(ctx, { inventoryLevel: { __args: { id }, ...inventoryLevelSelection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.inventoryLevel, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "activate") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "inventory-item-id": { type: "string" },
+        "variant-id": { type: "string" },
+        "location-id": { type: "string" },
+        available: { type: "string" },
+        "on-hand": { type: "string" },
+        "stock-at-legacy-location": { type: "string" }
+      }
+    });
+    const locationId2 = (0, import_shared.requireLocationId)(args2["location-id"]);
+    const inventoryItemId2 = await (0, import_resolveInventoryItemId.resolveInventoryItemId)({
+      ctx,
+      inventoryItemId: args2["inventory-item-id"],
+      variantId: args2["variant-id"]
+    });
+    const available = parseOptionalInt(args2.available, "--available");
+    const onHand = parseOptionalInt(args2["on-hand"], "--on-hand");
+    const stockAtLegacyLocation = (() => {
+      const raw = args2["stock-at-legacy-location"];
+      if (raw === void 0) return void 0;
+      const v = raw.trim().toLowerCase();
+      if (v === "true" || v === "1" || v === "yes") return true;
+      if (v === "false" || v === "0" || v === "no") return false;
+      throw new import_errors.CliError("--stock-at-legacy-location must be true|false", 2);
+    })();
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryActivate: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: {
+          inventoryItemId: inventoryItemId2,
+          locationId: locationId2,
+          ...available === void 0 ? {} : { available },
+          ...onHand === void 0 ? {} : { onHand },
+          ...stockAtLegacyLocation === void 0 ? {} : { stockAtLegacyLocation }
+        },
+        inventoryLevel: inventoryLevelSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.inventoryActivate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.inventoryActivate?.inventoryLevel?.id ?? "");
+    (0, import_output.printJson)(result.inventoryActivate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "deactivate") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "inventory-level-id": { type: "string" } } });
+    const inventoryLevelIdRaw = args2["inventory-level-id"];
+    if (!inventoryLevelIdRaw) throw new import_errors.CliError("Missing --inventory-level-id", 2);
+    const inventoryLevelId = requireInventoryLevelId(inventoryLevelIdRaw);
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryDeactivate: {
+        __args: { inventoryLevelId },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.inventoryDeactivate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet || ctx.view === "ids") {
+      process.stdout.write(`${inventoryLevelId}
+`);
+      return;
+    }
+    const out = { inventoryLevelId, deactivated: true };
+    (0, import_output.printNode)({ node: out, format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "bulk-toggle-activation") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "inventory-item-id": { type: "string" },
+        "variant-id": { type: "string" },
+        updates: { type: "string" },
+        "location-id": { type: "string" },
+        activate: { type: "string" }
+      }
+    });
+    const inventoryItemId2 = await (0, import_resolveInventoryItemId.resolveInventoryItemId)({
+      ctx,
+      inventoryItemId: args2["inventory-item-id"],
+      variantId: args2["variant-id"]
+    });
+    const updatesRaw = args2.updates;
+    const parsedUpdates = updatesRaw ? (0, import_shared.parseJsonArg)(updatesRaw, "--updates") : void 0;
+    const inventoryItemUpdates = (() => {
+      if (Array.isArray(parsedUpdates)) return parsedUpdates;
+      const locationIdRaw = args2["location-id"];
+      const activateRaw = args2.activate;
+      if (locationIdRaw && activateRaw !== void 0) {
+        const v = activateRaw.trim().toLowerCase();
+        const activate = v === "true" || v === "1" || v === "yes" ? true : v === "false" || v === "0" || v === "no" ? false : (() => {
+          throw new import_errors.CliError("--activate must be true|false", 2);
+        })();
+        return [{ locationId: (0, import_gid.coerceGid)(locationIdRaw, "Location"), activate }];
+      }
+      throw new import_errors.CliError("Missing --updates or (--location-id and --activate)", 2);
+    })();
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryBulkToggleActivation: {
+        __args: { inventoryItemId: inventoryItemId2, inventoryItemUpdates },
+        inventoryItem: { id: true, sku: true, tracked: true },
+        inventoryLevels: { id: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.inventoryBulkToggleActivation, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.inventoryBulkToggleActivation, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "set-on-hand-quantities") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "inventory-item-id": { type: "string" },
+        "variant-id": { type: "string" },
+        "location-id": { type: "string" },
+        "on-hand": { type: "string" },
+        "set-quantities": { type: "string" },
+        reason: { type: "string" },
+        "reference-document-uri": { type: "string" }
+      }
+    });
+    const reason2 = args2.reason ?? "correction";
+    const referenceDocumentUri2 = args2["reference-document-uri"];
+    const setQuantitiesRaw = args2["set-quantities"];
+    const parsed = setQuantitiesRaw ? (0, import_shared.parseJsonArg)(setQuantitiesRaw, "--set-quantities") : void 0;
+    if (parsed !== void 0 && !Array.isArray(parsed)) {
+      throw new import_errors.CliError("--set-quantities must be a JSON array", 2);
+    }
+    const setQuantities = (() => {
+      if (Array.isArray(parsed)) return parsed;
+      return void 0;
+    })();
+    const locationIdRaw = args2["location-id"];
+    const onHandRaw = args2["on-hand"];
+    const builtSetQuantities = setQuantities ?? (locationIdRaw && onHandRaw !== void 0 ? [
+      {
+        inventoryItemId: "__RESOLVE__",
+        locationId: (0, import_shared.requireLocationId)(locationIdRaw),
+        quantity: (0, import_shared.parseIntFlag)("--on-hand", onHandRaw)
+      }
+    ] : void 0);
+    const finalSetQuantities = builtSetQuantities;
+    if (!finalSetQuantities) throw new import_errors.CliError("Missing --set-quantities (or --location-id and --on-hand)", 2);
+    for (const q of finalSetQuantities) {
+      if (q && typeof q === "object" && q.inventoryItemId === "__RESOLVE__") {
+        const inventoryItemId2 = await (0, import_resolveInventoryItemId.resolveInventoryItemId)({
+          ctx,
+          inventoryItemId: args2["inventory-item-id"],
+          variantId: args2["variant-id"]
+        });
+        q.inventoryItemId = inventoryItemId2;
+      }
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventorySetOnHandQuantities: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: { input: { reason: reason2, ...referenceDocumentUri2 ? { referenceDocumentUri: referenceDocumentUri2 } : {}, setQuantities: finalSetQuantities } },
+        inventoryAdjustmentGroup: { id: true, reason: true, createdAt: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventorySetOnHandQuantities,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.inventorySetOnHandQuantities?.inventoryAdjustmentGroup?.id ?? "");
+    (0, import_output.printJson)(result.inventorySetOnHandQuantities, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "set-scheduled-changes") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        reason: { type: "string" },
+        items: { type: "string" },
+        "reference-document-uri": { type: "string" }
+      }
+    });
+    const reason2 = args2.reason ?? "correction";
+    const referenceDocumentUriRaw = args2["reference-document-uri"];
+    if (referenceDocumentUriRaw === void 0) throw new import_errors.CliError("Missing --reference-document-uri", 2);
+    const referenceDocumentUri2 = (0, import_shared.parseTextArg)(referenceDocumentUriRaw, "--reference-document-uri");
+    const itemsRaw = args2.items;
+    if (itemsRaw === void 0) 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, {
+      inventorySetScheduledChanges: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: { input: { reason: reason2, items, referenceDocumentUri: referenceDocumentUri2 } },
+        scheduledChanges: { expectedAt: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventorySetScheduledChanges,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    (0, import_output.printJson)(result.inventorySetScheduledChanges, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "transfer-set-items") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "transfer-id": { type: "string" },
+        "line-items": { type: "string" }
+      }
+    });
+    const transferIdRaw = args2["transfer-id"];
+    if (!transferIdRaw) throw new import_errors.CliError("Missing --transfer-id", 2);
+    const transferId = requireInventoryTransferId(transferIdRaw);
+    if (args2["line-items"] === void 0) throw new import_errors.CliError("Missing --line-items", 2);
+    const lineItems = (0, import_shared.parseJsonArg)(args2["line-items"], "--line-items");
+    if (!Array.isArray(lineItems)) throw new import_errors.CliError("--line-items must be a JSON array", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryTransferSetItems: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: { input: { id: transferId, lineItems } },
+        inventoryTransfer: { id: true, status: true },
+        updatedLineItems: { inventoryItemId: true, deltaQuantity: true, newQuantity: true },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventoryTransferSetItems,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.inventoryTransferSetItems?.inventoryTransfer?.id ?? "");
+    (0, import_output.printJson)(result.inventoryTransferSetItems, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "list") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "location-id": { type: "string" }
+      }
+    });
+    const locationId2 = (0, import_shared.requireLocationId)(args2["location-id"]);
+    const first = (0, import_shared.parseFirst)(args2.first);
+    const after = args2.after;
+    const query = args2.query;
+    const result = await (0, import_router.runQuery)(ctx, {
+      location: {
+        __args: { id: locationId2 },
+        id: true,
+        name: true,
+        inventoryLevels: {
+          __args: { first, after, query },
+          pageInfo: { hasNextPage: true, endCursor: true },
+          nodes: {
+            id: true,
+            updatedAt: true,
+            item: { id: true, sku: true, tracked: true },
+            quantities: { __args: { names: ["available"] }, name: true, quantity: true, updatedAt: true }
+          }
+        }
+      }
+    });
+    if (result === void 0) return;
+    const connection = result.location?.inventoryLevels ?? { nodes: [], pageInfo: void 0 };
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "inventory",
+        { first, query },
+        [{ flag: "--location-id", value: locationId2 }]
+      )
+    });
+    return;
+  }
+  if (verb !== "set" && verb !== "adjust" && verb !== "move") {
+    throw new import_errors.CliError(`Unknown verb for inventory: ${verb}`, 2);
+  }
+  const args = (0, import_router.parseStandardArgs)({
+    argv,
+    extraOptions: {
+      "inventory-item-id": { type: "string" },
+      "variant-id": { type: "string" },
+      "location-id": { type: "string" },
+      "from-location-id": { type: "string" },
+      "to-location-id": { type: "string" },
+      available: { type: "string" },
+      delta: { type: "string" },
+      quantity: { type: "string" },
+      "quantity-name": { type: "string" },
+      reason: { type: "string" },
+      "reference-document-uri": { type: "string" }
+    }
+  });
+  const locationId = verb === "move" ? void 0 : (0, import_shared.requireLocationId)(args["location-id"]);
+  const inventoryItemId = await (0, import_resolveInventoryItemId.resolveInventoryItemId)({
+    ctx,
+    inventoryItemId: args["inventory-item-id"],
+    variantId: args["variant-id"]
+  });
+  const reason = args.reason ?? "correction";
+  const referenceDocumentUri = args["reference-document-uri"];
+  if (verb === "set") {
+    const available = (0, import_shared.parseIntFlag)("--available", args.available);
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventorySetQuantities: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: {
+          input: {
+            name: "available",
+            reason,
+            ...referenceDocumentUri ? { referenceDocumentUri } : {},
+            quantities: [
+              {
+                inventoryItemId,
+                locationId,
+                quantity: available,
+                changeFromQuantity: null
+              }
+            ]
+          }
+        },
+        inventoryAdjustmentGroup: inventoryAdjustmentGroupSelection({
+          inventoryItemId,
+          locationIds: [locationId]
+        }),
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventorySetQuantities,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.inventorySetQuantities?.inventoryAdjustmentGroup?.id ?? "");
+    (0, import_output.printJson)(result.inventorySetQuantities);
+    return;
+  }
+  if (verb === "adjust") {
+    const delta = (0, import_shared.parseIntFlag)("--delta", args.delta);
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryAdjustQuantities: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: {
+          input: {
+            name: "available",
+            reason,
+            ...referenceDocumentUri ? { referenceDocumentUri } : {},
+            changes: [
+              {
+                inventoryItemId,
+                locationId,
+                delta,
+                changeFromQuantity: null
+              }
+            ]
+          }
+        },
+        inventoryAdjustmentGroup: inventoryAdjustmentGroupSelection({
+          inventoryItemId,
+          locationIds: [locationId]
+        }),
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventoryAdjustQuantities,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.inventoryAdjustQuantities?.inventoryAdjustmentGroup?.id ?? "");
+    (0, import_output.printJson)(result.inventoryAdjustQuantities);
+    return;
+  }
+  if (verb === "move") {
+    const fromLocationIdRaw = args["from-location-id"];
+    const toLocationIdRaw = args["to-location-id"];
+    if (!fromLocationIdRaw) throw new import_errors.CliError("Missing --from-location-id", 2);
+    if (!toLocationIdRaw) throw new import_errors.CliError("Missing --to-location-id", 2);
+    const fromLocationId = (0, import_shared.requireLocationId)(fromLocationIdRaw, "--from-location-id");
+    const toLocationId = (0, import_shared.requireLocationId)(toLocationIdRaw, "--to-location-id");
+    const quantity = (0, import_shared.parseIntFlag)("--quantity", args.quantity);
+    const quantityName = args["quantity-name"] ?? "available";
+    if (!referenceDocumentUri) {
+      throw new import_errors.CliError("Missing --reference-document-uri (required for inventory move)", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      inventoryMoveQuantities: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: {
+          input: {
+            reason,
+            referenceDocumentUri,
+            changes: [
+              {
+                inventoryItemId,
+                quantity,
+                from: { locationId: fromLocationId, name: quantityName, changeFromQuantity: null },
+                to: { locationId: toLocationId, name: quantityName, changeFromQuantity: null }
+              }
+            ]
+          }
+        },
+        inventoryAdjustmentGroup: inventoryAdjustmentGroupSelection({
+          inventoryItemId,
+          locationIds: [fromLocationId, toLocationId]
+        }),
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.inventoryMoveQuantities,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.inventoryMoveQuantities?.inventoryAdjustmentGroup?.id ?? "");
+    (0, import_output.printJson)(result.inventoryMoveQuantities);
+    return;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runInventory
+});
+//# sourceMappingURL=inventory.js.map

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

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

package/dist/cli/verbs/locales.js

@@ -0,0 +1,61 @@
+"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 locales_exports = {};
+__export(locales_exports, {
+  runLocales: () => runLocales
+});
+module.exports = __toCommonJS(locales_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+const localeSelection = {
+  isoCode: true,
+  name: true
+};
+const runLocales = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop locales <verb> [flags]",
+        "",
+        "Verbs:",
+        "  available"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "available") {
+    const result = await (0, import_router.runQuery)(ctx, { availableLocales: localeSelection });
+    if (result === void 0) return;
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.availableLocales, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for locales: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runLocales
+});
+//# sourceMappingURL=locales.js.map

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

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