shop-cli 0.1.1

package/dist/cli/workflows/products/publishablePublish.js

@@ -0,0 +1,131 @@
+"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 publishablePublish_exports = {};
+__export(publishablePublish_exports, {
+  parsePublishDate: () => parsePublishDate,
+  publishProduct: () => publishProduct,
+  resolvePublicationIds: () => resolvePublicationIds,
+  unpublishProduct: () => unpublishProduct
+});
+module.exports = __toCommonJS(publishablePublish_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_router = require("../../router");
+var import_userErrors = require("../../userErrors");
+var import_resolvePublicationId = require("../publications/resolvePublicationId");
+const requireProductId = (id) => {
+  if (!id) throw new import_errors.CliError("Missing --id", 2);
+  return (0, import_gid.coerceGid)(id, "Product");
+};
+const parsePublishDate = ({
+  at,
+  now
+}) => {
+  if (at && now) throw new import_errors.CliError("Pass either --at <iso> or --now, not both", 2);
+  if (now) return (/* @__PURE__ */ new Date()).toISOString();
+  return at;
+};
+const normalizePublicationId = (value) => {
+  const raw = value.trim();
+  if (!raw) throw new import_errors.CliError("publication ID cannot be empty", 2);
+  if ((0, import_gid.isGid)(raw)) {
+    if (!raw.startsWith("gid://shopify/Publication/")) {
+      throw new import_errors.CliError(`Expected a Publication GID (gid://shopify/Publication/...). Got: ${value}`, 2);
+    }
+    return raw;
+  }
+  if (/^\d+$/.test(raw)) return (0, import_gid.coerceGid)(raw, "Publication");
+  throw new import_errors.CliError(`Expected a numeric ID or full GID for Publication. Got: ${value}`, 2);
+};
+const resolvePublicationIds = async ({
+  ctx,
+  publicationIds,
+  publicationNames
+}) => {
+  if (ctx.dryRun && publicationNames.length > 0) {
+    throw new import_errors.CliError(
+      "In --dry-run mode, --publication cannot be resolved without executing a query. Use --publication-id <gid|num> instead.",
+      2
+    );
+  }
+  const ids = publicationIds.map(normalizePublicationId);
+  if (publicationNames.length > 0) {
+    const publications = await (0, import_resolvePublicationId.listPublications)(ctx);
+    for (const name of publicationNames) {
+      ids.push((0, import_resolvePublicationId.resolvePublicationIdFromList)({ publications, identifier: name }));
+    }
+  }
+  const unique = Array.from(new Set(ids));
+  if (unique.length === 0) throw new import_errors.CliError("Missing --publication-id or --publication", 2);
+  return unique;
+};
+const publishProduct = async ({
+  ctx,
+  id,
+  publicationIds,
+  publishDate
+}) => {
+  const productId = requireProductId(id);
+  const input = publicationIds.map((publicationId) => ({
+    publicationId,
+    ...publishDate ? { publishDate } : {}
+  }));
+  const result = await (0, import_router.runMutation)(ctx, {
+    publishablePublish: {
+      __args: { id: productId, input },
+      publishable: { __typename: true, on_Product: { id: true } },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.publishablePublish,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  return result.publishablePublish;
+};
+const unpublishProduct = async ({
+  ctx,
+  id,
+  publicationIds
+}) => {
+  const productId = requireProductId(id);
+  const input = publicationIds.map((publicationId) => ({ publicationId }));
+  const result = await (0, import_router.runMutation)(ctx, {
+    publishableUnpublish: {
+      __args: { id: productId, input },
+      publishable: { __typename: true, on_Product: { id: true } },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.publishableUnpublish,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  return result.publishableUnpublish;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePublishDate,
+  publishProduct,
+  resolvePublicationIds,
+  unpublishProduct
+});
+//# sourceMappingURL=publishablePublish.js.map

package/dist/cli/workflows/publications/resolvePublicationId.d.ts

@@ -0,0 +1,17 @@
+import { type CommandContext } from '../../router';
+export type PublicationSummary = {
+    id: string;
+    name?: string | null;
+    catalogTitle?: string | null;
+    autoPublish?: boolean | null;
+};
+export declare const listPublications: (ctx: CommandContext) => Promise<PublicationSummary[]>;
+export declare const resolvePublicationIdFromList: ({ publications, identifier, }: {
+    publications: PublicationSummary[];
+    identifier: string;
+}) => string;
+export declare const resolvePublicationId: ({ ctx, publications, identifier, }: {
+    ctx: CommandContext;
+    publications?: PublicationSummary[];
+    identifier: string;
+}) => Promise<string>;

package/dist/cli/workflows/publications/resolvePublicationId.js

@@ -0,0 +1,93 @@
+"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 resolvePublicationId_exports = {};
+__export(resolvePublicationId_exports, {
+  listPublications: () => listPublications,
+  resolvePublicationId: () => resolvePublicationId,
+  resolvePublicationIdFromList: () => resolvePublicationIdFromList
+});
+module.exports = __toCommonJS(resolvePublicationId_exports);
+var import_errors = require("../../errors");
+var import_gid = require("../../gid");
+var import_router = require("../../router");
+const listPublications = async (ctx) => {
+  const result = await (0, import_router.runQuery)(ctx, {
+    publications: {
+      __args: { first: 250 },
+      nodes: {
+        id: true,
+        name: true,
+        autoPublish: true,
+        catalog: { title: true }
+      }
+    }
+  });
+  if (result === void 0) return [];
+  const nodes = result.publications?.nodes ?? [];
+  return nodes.map((p) => ({
+    id: p?.id,
+    name: p?.name,
+    catalogTitle: p?.catalog?.title,
+    autoPublish: p?.autoPublish
+  }));
+};
+const normalize = (value) => value.trim().toLowerCase();
+const resolvePublicationIdFromList = ({
+  publications,
+  identifier
+}) => {
+  const raw = identifier.trim();
+  if (!raw) throw new import_errors.CliError("Missing publication identifier", 2);
+  if ((0, import_gid.isGid)(raw)) {
+    if (!raw.startsWith("gid://shopify/Publication/")) {
+      throw new import_errors.CliError(`Expected a Publication GID (gid://shopify/Publication/...). Got: ${raw}`, 2);
+    }
+    return raw;
+  }
+  if (/^\d+$/.test(raw)) return (0, import_gid.coerceGid)(raw, "Publication");
+  const target = normalize(raw);
+  const matches = publications.filter((p) => {
+    const names = [p.name, p.catalogTitle].filter((v) => Boolean(v));
+    return names.some((n) => normalize(n) === target);
+  });
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new import_errors.CliError(
+      `Publication name is ambiguous (${raw}): ${matches.map((m) => `${m.name ?? m.catalogTitle ?? "(unknown)"} (${m.id})`).join(", ")}`,
+      2
+    );
+  }
+  const hint = publications.length === 0 ? "" : ` Known publications: ${publications.map((p) => p.name ?? p.catalogTitle ?? "(unknown)").filter((v, i, arr) => v && arr.indexOf(v) === i).slice(0, 12).join(", ")}`;
+  throw new import_errors.CliError(`No publication found matching: ${raw}.${hint}`, 2);
+};
+const resolvePublicationId = async ({
+  ctx,
+  publications,
+  identifier
+}) => {
+  const list = publications ?? await listPublications(ctx);
+  return resolvePublicationIdFromList({ publications: list, identifier });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listPublications,
+  resolvePublicationId,
+  resolvePublicationIdFromList
+});
+//# sourceMappingURL=resolvePublicationId.js.map

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,238 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_dotenv = __toESM(require("dotenv"));
+var import_path = require("path");
+var import_client = require("./cli/client");
+var import_errors = require("./cli/errors");
+var import_globalFlags = require("./cli/globalFlags");
+var import_headers = require("./cli/headers");
+var import_render = require("./cli/help/render");
+var import_registry = require("./cli/help/registry");
+var import_router = require("./cli/router");
+var import_adminClient = require("./adminClient");
+var import_defaults = require("./defaults");
+var import_command = require("./cli/command");
+var import_parse_command = require("./cli/parse-command");
+var import_output = require("./cli/output");
+var import_suggest = require("./cli/suggest");
+import_dotenv.default.config({ path: (0, import_path.resolve)(process.cwd(), ".env"), quiet: true });
+const helpFlags = /* @__PURE__ */ new Set(["--help", "-h", "--help-full", "--help-all"]);
+const versionFlags = /* @__PURE__ */ new Set(["--version", "-v"]);
+const hasHelpFlag = (args) => args.some((arg) => helpFlags.has(arg));
+const hasVersionFlag = (args) => args.some((arg) => versionFlags.has(arg));
+const wantsFullHelp = (args) => args.some((arg) => arg === "--help-full" || arg === "--help-all");
+const formatDidYouMean = (suggestions) => {
+  if (suggestions.length === 0) return "";
+  return ["Did you mean:", ...suggestions.map((s) => `  ${s}`)].join("\n");
+};
+const printVersion = async () => {
+  const fs = await import("fs");
+  const path = await import("path");
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      console.log(pkg.version);
+      return;
+    }
+    dir = path.dirname(dir);
+  }
+  console.log("unknown");
+};
+const main = async () => {
+  const command = (0, import_command.resolveCliCommand)();
+  (0, import_output.setGlobalCommand)(command);
+  const argv = process.argv.slice(2);
+  if (hasVersionFlag(argv)) {
+    await printVersion();
+    return;
+  }
+  if (argv.length === 0 || argv[0] === "help" || hasHelpFlag([argv[0]])) {
+    console.log((0, import_render.renderTopLevelHelp)(command));
+    return;
+  }
+  const resource = argv[0];
+  if (!resource) {
+    console.log((0, import_render.renderTopLevelHelp)(command));
+    throw new import_errors.CliError("Missing <resource>", 2);
+  }
+  const afterResource = argv.slice(1);
+  const { verb, rest } = (0, import_parse_command.parseVerbAndRest)({ resource, afterResource });
+  const rewrittenRest = (0, import_parse_command.rewritePositionalIdAsFlag)({ resource, verb, rest });
+  const isTypesCommand = resource === "types";
+  if (!verb) {
+    if (isTypesCommand && hasHelpFlag(afterResource)) {
+    } else {
+      const resourceHelp = (0, import_render.renderResourceHelp)(resource, command);
+      if (resourceHelp) {
+        console.log(resourceHelp);
+        if (hasHelpFlag(afterResource)) return;
+        throw new import_errors.CliError(`
+Missing <verb> for "${resource}"`, 2);
+      } else if (!isTypesCommand) {
+        const resources = import_registry.commandRegistry.map((r) => r.resource);
+        const matches = (0, import_suggest.findSuggestions)({ query: resource, candidates: resources, limit: 3 });
+        const suggestions = matches.map(
+          (r) => [command, r, ...afterResource].filter(Boolean).join(" ").trim()
+        );
+        const didYouMean = formatDidYouMean(suggestions);
+        throw new import_errors.CliError(
+          [`Unknown resource: ${resource}`, didYouMean].filter(Boolean).join("\n"),
+          2
+        );
+      }
+    }
+  }
+  if (hasHelpFlag(rewrittenRest)) {
+    if (isTypesCommand) {
+    } else {
+      const verbHelp = (0, import_render.renderVerbHelp)(resource, verb, { showAllFields: wantsFullHelp(rewrittenRest) }, command);
+      if (verbHelp) {
+        console.log(verbHelp);
+        return;
+      }
+      const verbGroupHelp = (0, import_render.renderVerbGroupHelp)(resource, verb, command);
+      if (verbGroupHelp) {
+        console.log(verbGroupHelp);
+        return;
+      }
+      const resourceHelp = (0, import_render.renderResourceHelp)(resource, command);
+      if (resourceHelp) {
+        console.log(resourceHelp);
+        return;
+      }
+      console.log((0, import_render.renderTopLevelHelp)(command));
+      return;
+    }
+  }
+  const unexpectedPositionalHint = (0, import_parse_command.buildUnexpectedPositionalHint)({ command, resource, verb, rest: rewrittenRest });
+  if (unexpectedPositionalHint) {
+    throw new import_errors.CliError(unexpectedPositionalHint, 2);
+  }
+  const parsed = (0, import_globalFlags.parseGlobalFlags)(rewrittenRest);
+  const dryRun = parsed.dryRun ?? false;
+  const isOfflineCommand = verb === "fields" || isTypesCommand;
+  const shopDomain = parsed.shopDomain;
+  const graphqlEndpoint = parsed.graphqlEndpoint;
+  const accessToken = parsed.accessToken;
+  const envHeaders = (0, import_headers.parseHeadersFromEnv)(process.env.SHOPIFY_HEADERS);
+  const cliHeaders = (0, import_headers.parseHeaderValues)(parsed.headers, "--header");
+  const headers = { ...envHeaders, ...cliHeaders };
+  const resolvedAccessToken = accessToken ?? process.env.SHOPIFY_ACCESS_TOKEN;
+  const hasAuthHeader = Object.keys(headers).some((name) => {
+    const normalized = name.toLowerCase();
+    return normalized === "authorization" || normalized === "x-shopify-access-token";
+  });
+  const apiVersion = parsed.apiVersion;
+  const warnMissingAccessToken = !resolvedAccessToken && !hasAuthHeader;
+  const verbose = parsed.verbose ?? false;
+  const resolvedApiVersion = (0, import_defaults.resolveAdminApiVersion)(apiVersion ?? process.env.SHOPIFY_API_VERSION);
+  const client = dryRun || isOfflineCommand ? (0, import_adminClient.createShopifyAdminClient)({
+    shopDomain: shopDomain ?? process.env.SHOPIFY_SHOP ?? "example.myshopify.com",
+    graphqlEndpoint: graphqlEndpoint ?? process.env.GRAPHQL_ENDPOINT,
+    accessToken: resolvedAccessToken ?? "DUMMY",
+    apiVersion: resolvedApiVersion,
+    headers,
+    verbose
+  }) : (0, import_client.createCliClientFromEnv)({
+    shopDomain,
+    graphqlEndpoint,
+    accessToken,
+    apiVersion,
+    headers,
+    verbose
+  });
+  try {
+    await (0, import_router.runCommand)({
+      client,
+      resource,
+      verb,
+      argv: parsed.passthrough,
+      format: parsed.format ?? (isOfflineCommand ? "table" : "json"),
+      quiet: parsed.quiet ?? false,
+      view: parsed.view ?? "summary",
+      dryRun,
+      failOnUserErrors: !(parsed.noFailOnUserErrors ?? false),
+      warnMissingAccessToken,
+      // Raw GraphQL client options (for graphql command)
+      shopDomain: shopDomain ?? process.env.SHOPIFY_SHOP,
+      graphqlEndpoint: graphqlEndpoint ?? process.env.GRAPHQL_ENDPOINT,
+      accessToken: resolvedAccessToken,
+      apiVersion: resolvedApiVersion,
+      headers
+    });
+  } catch (err) {
+    if (!(err instanceof import_errors.CliError)) throw err;
+    let message = err.message;
+    const unknownResourceMatch = message.match(/^Unknown resource: (.+)$/);
+    if (unknownResourceMatch) {
+      const unknown = unknownResourceMatch[1] ?? resource;
+      const resources = import_registry.commandRegistry.map((r) => r.resource);
+      const matches = (0, import_suggest.findSuggestions)({ query: unknown, candidates: resources, limit: 3 });
+      const suggestions = matches.map(
+        (r) => [command, r, ...afterResource].filter(Boolean).join(" ").trim()
+      );
+      const didYouMean = formatDidYouMean(suggestions);
+      message = [`Unknown resource: ${unknown}`, didYouMean].filter(Boolean).join("\n");
+      throw new import_errors.CliError(message, err.exitCode);
+    }
+    const unknownVerbMatch = message.match(/^Unknown verb for ([^:]+): (.+)$/);
+    if (unknownVerbMatch) {
+      const resourceName = unknownVerbMatch[1];
+      const unknownVerb = unknownVerbMatch[2];
+      const spec = import_registry.commandRegistry.find((r) => r.resource === resourceName);
+      if (spec) {
+        const groups = new Set(
+          spec.verbs.map((v) => v.verb).filter((v) => v.includes(" ")).map((v) => v.split(" ")[0]).filter(Boolean)
+        );
+        const candidates = Array.from(
+          /* @__PURE__ */ new Set([...spec.verbs.map((v) => v.verb), ...Array.from(groups)])
+        );
+        const matches = (0, import_suggest.findSuggestions)({ query: unknownVerb, candidates, limit: 3 });
+        const suggestions = matches.map((v) => `${command} ${resourceName} ${v}`.trim());
+        const didYouMean = formatDidYouMean(suggestions);
+        if (didYouMean) {
+          message = [`Unknown verb for ${resourceName}: ${unknownVerb}`, didYouMean].join("\n");
+        }
+      }
+      throw new import_errors.CliError(message, err.exitCode);
+    }
+    if (err.exitCode === 2 && verb && !message.includes("See help:") && message.includes("--") && !message.startsWith("Unknown resource:") && !message.startsWith("Unknown verb for ")) {
+      message = `${message}
+See help:
+  ${command} ${resource} ${verb} --help`;
+    }
+    throw new import_errors.CliError(message, err.exitCode);
+  }
+};
+main().catch((err) => {
+  if (err instanceof import_errors.CliError) {
+    console.error(err.message);
+    process.exit(err.exitCode);
+  }
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ADMIN_API_VERSION: "2026-04";
+export declare const resolveAdminApiVersion: (apiVersion: unknown) => string;

package/dist/defaults.js

@@ -0,0 +1,38 @@
+"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 defaults_exports = {};
+__export(defaults_exports, {
+  DEFAULT_ADMIN_API_VERSION: () => DEFAULT_ADMIN_API_VERSION,
+  resolveAdminApiVersion: () => resolveAdminApiVersion
+});
+module.exports = __toCommonJS(defaults_exports);
+const DEFAULT_ADMIN_API_VERSION = "2026-04";
+const resolveAdminApiVersion = (apiVersion) => {
+  if (typeof apiVersion === "string") {
+    const trimmed = apiVersion.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return DEFAULT_ADMIN_API_VERSION;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_ADMIN_API_VERSION,
+  resolveAdminApiVersion
+});
+//# sourceMappingURL=defaults.js.map

package/dist/generated/admin-2026-04/index.d.ts

@@ -0,0 +1,25 @@
+import type { QueryRootGenqlSelection, QueryRoot, MutationGenqlSelection, Mutation } from './schema';
+import { type FieldsSelection, type GraphqlOperation, type ClientOptions, GenqlError } from './runtime';
+export type { FieldsSelection } from './runtime';
+export { GenqlError };
+export * from './schema';
+export interface Client {
+    query<R extends QueryRootGenqlSelection>(request: R & {
+        __name?: string;
+    }): Promise<FieldsSelection<QueryRoot, R>>;
+    mutation<R extends MutationGenqlSelection>(request: R & {
+        __name?: string;
+    }): Promise<FieldsSelection<Mutation, R>>;
+}
+export declare const createClient: (options?: ClientOptions) => Client;
+export declare const everything: {
+    __scalar: boolean;
+};
+export type QueryResult<fields extends QueryRootGenqlSelection> = FieldsSelection<QueryRoot, fields>;
+export declare const generateQueryOp: (fields: QueryRootGenqlSelection & {
+    __name?: string;
+}) => GraphqlOperation;
+export type MutationResult<fields extends MutationGenqlSelection> = FieldsSelection<Mutation, fields>;
+export declare const generateMutationOp: (fields: MutationGenqlSelection & {
+    __name?: string;
+}) => GraphqlOperation;

package/dist/generated/admin-2026-04/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var admin_2026_04_exports = {};
+__export(admin_2026_04_exports, {
+  GenqlError: () => import_runtime.GenqlError,
+  createClient: () => createClient,
+  everything: () => everything,
+  generateMutationOp: () => generateMutationOp,
+  generateQueryOp: () => generateQueryOp
+});
+module.exports = __toCommonJS(admin_2026_04_exports);
+var import_runtime = require("./runtime");
+var import_types = __toESM(require("./types"));
+__reExport(admin_2026_04_exports, require("./schema"), module.exports);
+const typeMap = (0, import_runtime.linkTypeMap)(import_types.default);
+const createClient = function(options) {
+  return (0, import_runtime.createClient)({
+    url: void 0,
+    ...options,
+    queryRoot: typeMap.Query,
+    mutationRoot: typeMap.Mutation,
+    subscriptionRoot: typeMap.Subscription
+  });
+};
+const everything = {
+  __scalar: true
+};
+const generateQueryOp = function(fields) {
+  return (0, import_runtime.generateGraphqlOperation)("query", typeMap.Query, fields);
+};
+const generateMutationOp = function(fields) {
+  return (0, import_runtime.generateGraphqlOperation)("mutation", typeMap.Mutation, fields);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenqlError,
+  createClient,
+  everything,
+  generateMutationOp,
+  generateQueryOp,
+  ...require("./schema")
+});
+//# sourceMappingURL=index.js.map