shop-cli 0.1.0

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

package/dist/generated/admin-2026-04/runtime/batcher.d.ts

@@ -0,0 +1,105 @@
+import type { GraphqlOperation } from './generateGraphqlOperation';
+type Variables = Record<string, any>;
+type QueryError = Error & {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: any;
+    rid: string;
+    details?: Record<string, any>;
+};
+type Result = {
+    data: Record<string, any>;
+    errors: Array<QueryError>;
+};
+type Fetcher = (batchedQuery: GraphqlOperation | Array<GraphqlOperation>) => Promise<Array<Result>>;
+type Options = {
+    batchInterval?: number;
+    shouldBatch?: boolean;
+    maxBatchSize?: number;
+};
+type Queue = Array<{
+    request: GraphqlOperation;
+    resolve: (...args: Array<any>) => any;
+    reject: (...args: Array<any>) => any;
+}>;
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+export declare class QueryBatcher {
+    fetcher: Fetcher;
+    _options: Options;
+    _queue: Queue;
+    constructor(fetcher: Fetcher, { batchInterval, shouldBatch, maxBatchSize, }?: Options);
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+}
+export {};

package/dist/generated/admin-2026-04/runtime/batcher.js

@@ -0,0 +1,203 @@
+"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 batcher_exports = {};
+__export(batcher_exports, {
+  QueryBatcher: () => QueryBatcher
+});
+module.exports = __toCommonJS(batcher_exports);
+var import_error = require("./error");
+function dispatchQueueBatch(client, queue) {
+  let batchedQuery = queue.map((item) => item.request);
+  if (batchedQuery.length === 1) {
+    batchedQuery = batchedQuery[0];
+  }
+  (() => {
+    try {
+      return client.fetcher(batchedQuery);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  })().then((responses) => {
+    if (queue.length === 1 && !Array.isArray(responses)) {
+      if (responses.errors && responses.errors.length) {
+        queue[0].reject(
+          new import_error.GenqlError(responses.errors, responses.data)
+        );
+        return;
+      }
+      queue[0].resolve(responses);
+      return;
+    } else if (responses.length !== queue.length) {
+      throw new Error("response length did not match query length");
+    }
+    for (let i = 0; i < queue.length; i++) {
+      if (responses[i].errors && responses[i].errors.length) {
+        queue[i].reject(
+          new import_error.GenqlError(responses[i].errors, responses[i].data)
+        );
+      } else {
+        queue[i].resolve(responses[i]);
+      }
+    }
+  }).catch((e) => {
+    for (let i = 0; i < queue.length; i++) {
+      queue[i].reject(e);
+    }
+  });
+}
+function dispatchQueue(client, options) {
+  const queue = client._queue;
+  const maxBatchSize = options.maxBatchSize || 0;
+  client._queue = [];
+  if (maxBatchSize > 0 && maxBatchSize < queue.length) {
+    for (let i = 0; i < queue.length / maxBatchSize; i++) {
+      dispatchQueueBatch(
+        client,
+        queue.slice(i * maxBatchSize, (i + 1) * maxBatchSize)
+      );
+    }
+  } else {
+    dispatchQueueBatch(client, queue);
+  }
+}
+class QueryBatcher {
+  fetcher;
+  _options;
+  _queue;
+  constructor(fetcher, {
+    batchInterval = 6,
+    shouldBatch = true,
+    maxBatchSize = 0
+  } = {}) {
+    this.fetcher = fetcher;
+    this._options = {
+      batchInterval,
+      shouldBatch,
+      maxBatchSize
+    };
+    this._queue = [];
+  }
+  /**
+   * Fetch will send a graphql request and return the parsed json.
+   * @param {string}      query          - the graphql query.
+   * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+   * @param {[string]}    operationName  - the graphql operationName.
+   * @param {Options}     overrides      - the client options overrides.
+   *
+   * @return {promise} resolves to parsed json of server response
+   *
+   * @example
+   * client.fetch(`
+   *    query getHuman($id: ID!) {
+   *      human(id: $id) {
+   *        name
+   *        height
+   *      }
+   *    }
+   * `, { id: "1001" }, 'getHuman')
+   *    .then(human => {
+   *      // do something with human
+   *      console.log(human);
+   *    });
+   */
+  fetch(query, variables, operationName, overrides = {}) {
+    const request = {
+      query
+    };
+    const options = Object.assign({}, this._options, overrides);
+    if (variables) {
+      request.variables = variables;
+    }
+    if (operationName) {
+      request.operationName = operationName;
+    }
+    const promise = new Promise((resolve, reject) => {
+      this._queue.push({
+        request,
+        resolve,
+        reject
+      });
+      if (this._queue.length === 1) {
+        if (options.shouldBatch) {
+          setTimeout(
+            () => dispatchQueue(this, options),
+            options.batchInterval
+          );
+        } else {
+          dispatchQueue(this, options);
+        }
+      }
+    });
+    return promise;
+  }
+  /**
+   * Fetch will send a graphql request and return the parsed json.
+   * @param {string}      query          - the graphql query.
+   * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+   * @param {[string]}    operationName  - the graphql operationName.
+   * @param {Options}     overrides      - the client options overrides.
+   *
+   * @return {Promise<Array<Result>>} resolves to parsed json of server response
+   *
+   * @example
+   * client.forceFetch(`
+   *    query getHuman($id: ID!) {
+   *      human(id: $id) {
+   *        name
+   *        height
+   *      }
+   *    }
+   * `, { id: "1001" }, 'getHuman')
+   *    .then(human => {
+   *      // do something with human
+   *      console.log(human);
+   *    });
+   */
+  forceFetch(query, variables, operationName, overrides = {}) {
+    const request = {
+      query
+    };
+    const options = Object.assign({}, this._options, overrides, {
+      shouldBatch: false
+    });
+    if (variables) {
+      request.variables = variables;
+    }
+    if (operationName) {
+      request.operationName = operationName;
+    }
+    const promise = new Promise((resolve, reject) => {
+      const client = new QueryBatcher(this.fetcher, this._options);
+      client._queue = [
+        {
+          request,
+          resolve,
+          reject
+        }
+      ];
+      dispatchQueue(client, options);
+    });
+    return promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryBatcher
+});
+//# sourceMappingURL=batcher.js.map

package/dist/generated/admin-2026-04/runtime/createClient.d.ts

@@ -0,0 +1,17 @@
+import { type BatchOptions } from './fetcher';
+import type { ExecutionResult, LinkedType } from './types';
+import { type GraphqlOperation } from './generateGraphqlOperation';
+export type Headers = HeadersInit | (() => HeadersInit) | (() => Promise<HeadersInit>);
+export type BaseFetcher = (operation: GraphqlOperation | GraphqlOperation[]) => Promise<ExecutionResult | ExecutionResult[]>;
+export type ClientOptions = Omit<RequestInit, 'body' | 'headers'> & {
+    url?: string;
+    batch?: BatchOptions | boolean;
+    fetcher?: BaseFetcher;
+    fetch?: Function;
+    headers?: Headers;
+};
+export declare const createClient: ({ queryRoot, mutationRoot, subscriptionRoot, ...options }: ClientOptions & {
+    queryRoot?: LinkedType;
+    mutationRoot?: LinkedType;
+    subscriptionRoot?: LinkedType;
+}) => any;

package/dist/generated/admin-2026-04/runtime/createClient.js

@@ -0,0 +1,59 @@
+"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 createClient_exports = {};
+__export(createClient_exports, {
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(createClient_exports);
+var import_fetcher = require("./fetcher");
+var import_generateGraphqlOperation = require("./generateGraphqlOperation");
+const createClient = ({
+  queryRoot,
+  mutationRoot,
+  subscriptionRoot,
+  ...options
+}) => {
+  const fetcher = (0, import_fetcher.createFetcher)(options);
+  const client = {};
+  if (queryRoot) {
+    client.query = (request) => {
+      if (!queryRoot) throw new Error("queryRoot argument is missing");
+      const resultPromise = fetcher(
+        (0, import_generateGraphqlOperation.generateGraphqlOperation)("query", queryRoot, request)
+      );
+      return resultPromise;
+    };
+  }
+  if (mutationRoot) {
+    client.mutation = (request) => {
+      if (!mutationRoot)
+        throw new Error("mutationRoot argument is missing");
+      const resultPromise = fetcher(
+        (0, import_generateGraphqlOperation.generateGraphqlOperation)("mutation", mutationRoot, request)
+      );
+      return resultPromise;
+    };
+  }
+  return client;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClient
+});
+//# sourceMappingURL=createClient.js.map

package/dist/generated/admin-2026-04/runtime/error.d.ts

@@ -0,0 +1,18 @@
+export declare class GenqlError extends Error {
+    errors: Array<GraphqlError>;
+    /**
+     * Partial data returned by the server
+     */
+    data?: any;
+    constructor(errors: any[], data: any);
+}
+interface GraphqlError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: string[];
+    extensions?: Record<string, any>;
+}
+export {};

package/dist/generated/admin-2026-04/runtime/error.js

@@ -0,0 +1,44 @@
+"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 error_exports = {};
+__export(error_exports, {
+  GenqlError: () => GenqlError
+});
+module.exports = __toCommonJS(error_exports);
+class GenqlError extends Error {
+  errors = [];
+  /**
+   * Partial data returned by the server
+   */
+  data;
+  constructor(errors, data) {
+    let message = Array.isArray(errors) ? errors.map((x) => x?.message || "").join("\n") : "";
+    if (!message) {
+      message = "GraphQL error";
+    }
+    super(message);
+    this.errors = errors;
+    this.data = data;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenqlError
+});
+//# sourceMappingURL=error.js.map

package/dist/generated/admin-2026-04/runtime/fetcher.d.ts

@@ -0,0 +1,10 @@
+import type { ClientOptions } from './createClient';
+import type { GraphqlOperation } from './generateGraphqlOperation';
+export interface Fetcher {
+    (gql: GraphqlOperation): Promise<any>;
+}
+export type BatchOptions = {
+    batchInterval?: number;
+    maxBatchSize?: number;
+};
+export declare const createFetcher: ({ url, headers, fetcher, fetch: _fetch, batch, ...rest }: ClientOptions) => Fetcher;

package/dist/generated/admin-2026-04/runtime/fetcher.js

@@ -0,0 +1,104 @@
+"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 fetcher_exports = {};
+__export(fetcher_exports, {
+  createFetcher: () => createFetcher
+});
+module.exports = __toCommonJS(fetcher_exports);
+var import_batcher = require("./batcher");
+var import_error = require("./error");
+const DEFAULT_BATCH_OPTIONS = {
+  maxBatchSize: 10,
+  batchInterval: 40
+};
+const createFetcher = ({
+  url,
+  headers = {},
+  fetcher,
+  fetch: _fetch,
+  batch = false,
+  ...rest
+}) => {
+  if (!url && !fetcher) {
+    throw new Error("url or fetcher is required");
+  }
+  fetcher = fetcher || (async (body) => {
+    let headersObject = typeof headers == "function" ? await headers() : headers;
+    headersObject = headersObject || {};
+    if (typeof fetch === "undefined" && !_fetch) {
+      throw new Error(
+        "Global `fetch` function is not available, pass a fetch polyfill to Genql `createClient`"
+      );
+    }
+    let fetchImpl = _fetch || fetch;
+    const res = await fetchImpl(url, {
+      headers: {
+        "Content-Type": "application/json",
+        ...headersObject
+      },
+      method: "POST",
+      body: JSON.stringify(body),
+      ...rest
+    });
+    if (!res.ok) {
+      throw new Error(`${res.statusText}: ${await res.text()}`);
+    }
+    const json = await res.json();
+    return json;
+  });
+  if (!batch) {
+    return async (body) => {
+      const json = await fetcher(body);
+      if (Array.isArray(json)) {
+        return json.map((json2) => {
+          if (json2?.errors?.length) {
+            throw new import_error.GenqlError(json2.errors || [], json2.data);
+          }
+          return json2.data;
+        });
+      } else {
+        if (json?.errors?.length) {
+          throw new import_error.GenqlError(json.errors || [], json.data);
+        }
+        return json.data;
+      }
+    };
+  }
+  const batcher = new import_batcher.QueryBatcher(
+    async (batchedQuery) => {
+      const json = await fetcher(batchedQuery);
+      return json;
+    },
+    batch === true ? DEFAULT_BATCH_OPTIONS : batch
+  );
+  return async ({ query, variables }) => {
+    const json = await batcher.fetch(query, variables);
+    if (json?.data) {
+      return json.data;
+    }
+    throw new Error(
+      "Genql batch fetcher returned unexpected result " + JSON.stringify(json)
+    );
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFetcher
+});
+//# sourceMappingURL=fetcher.js.map

package/dist/generated/admin-2026-04/runtime/generateGraphqlOperation.d.ts

@@ -0,0 +1,30 @@
+import type { LinkedField, LinkedType } from './types';
+export interface Args {
+    [arg: string]: any | undefined;
+}
+export interface Fields {
+    [field: string]: Request;
+}
+export type Request = boolean | number | Fields;
+export interface Variables {
+    [name: string]: {
+        value: any;
+        typing: [LinkedType, string];
+    };
+}
+export interface Context {
+    root: LinkedType;
+    varCounter: number;
+    variables: Variables;
+    fragmentCounter: number;
+    fragments: string[];
+}
+export interface GraphqlOperation {
+    query: string;
+    variables?: {
+        [name: string]: any;
+    };
+    operationName?: string;
+}
+export declare const generateGraphqlOperation: (operation: "query" | "mutation" | "subscription", root: LinkedType, fields?: Fields) => GraphqlOperation;
+export declare const getFieldFromPath: (root: LinkedType | undefined, path: string[]) => LinkedField;