@clawconquest/client 1.1.1

package/dist/index.cjs

@@ -0,0 +1,1873 @@
+"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);
+
+// generated/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GenqlError: () => GenqlError,
+  createClient: () => createClient2,
+  enumApplicationStatus: () => enumApplicationStatus,
+  enumClanPactType: () => enumClanPactType,
+  enumClanStatus: () => enumClanStatus,
+  enumGovernanceType: () => enumGovernanceType,
+  enumMembershipPolicy: () => enumMembershipPolicy,
+  enumPactStatus: () => enumPactStatus,
+  enumPoolType: () => enumPoolType,
+  enumPrimaryGoal: () => enumPrimaryGoal,
+  enumSiegeStatus: () => enumSiegeStatus,
+  enumSpecies: () => enumSpecies,
+  enumUnitType: () => enumUnitType,
+  everything: () => everything,
+  generateMutationOp: () => generateMutationOp,
+  generateQueryOp: () => generateQueryOp,
+  generateSubscriptionOp: () => generateSubscriptionOp,
+  isClan: () => isClan,
+  isClanApplication: () => isClanApplication,
+  isClanPact: () => isClanPact,
+  isClaw: () => isClaw,
+  isClawSummary: () => isClawSummary,
+  isCreateClawPayload: () => isCreateClawPayload,
+  isGameEvent: () => isGameEvent,
+  isMutation: () => isMutation,
+  isPlayer: () => isPlayer,
+  isPlayerProfile: () => isPlayerProfile,
+  isPool: () => isPool,
+  isPublicClaw: () => isPublicClaw,
+  isQuery: () => isQuery,
+  isRegenerateKeyPayload: () => isRegenerateKeyPayload,
+  isRelationship: () => isRelationship,
+  isSiege: () => isSiege,
+  isSpyDeployment: () => isSpyDeployment,
+  isStandingOrder: () => isStandingOrder,
+  isSubscription: () => isSubscription,
+  isUnit: () => isUnit,
+  isWhisper: () => isWhisper
+});
+module.exports = __toCommonJS(index_exports);
+
+// generated/runtime/error.ts
+var GenqlError = class 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;
+  }
+};
+
+// generated/runtime/batcher.ts
+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 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 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);
+  }
+}
+var QueryBatcher = 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;
+  }
+};
+
+// generated/runtime/fetcher.ts
+var DEFAULT_BATCH_OPTIONS = {
+  maxBatchSize: 10,
+  batchInterval: 40
+};
+var 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 GenqlError(json2.errors || [], json2.data);
+          }
+          return json2.data;
+        });
+      } else {
+        if (json?.errors?.length) {
+          throw new GenqlError(json.errors || [], json.data);
+        }
+        return json.data;
+      }
+    };
+  }
+  const batcher = new 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)
+    );
+  };
+};
+
+// generated/runtime/generateGraphqlOperation.ts
+var parseRequest = (request, ctx, path) => {
+  if (typeof request === "object" && "__args" in request) {
+    const args = request.__args;
+    let fields = { ...request };
+    delete fields.__args;
+    const argNames = Object.keys(args);
+    if (argNames.length === 0) {
+      return parseRequest(fields, ctx, path);
+    }
+    const field = getFieldFromPath(ctx.root, path);
+    const argStrings = argNames.map((argName) => {
+      ctx.varCounter++;
+      const varName = `v${ctx.varCounter}`;
+      const typing = field.args && field.args[argName];
+      if (!typing) {
+        throw new Error(
+          `no typing defined for argument \`${argName}\` in path \`${path.join(
+            "."
+          )}\``
+        );
+      }
+      ctx.variables[varName] = {
+        value: args[argName],
+        typing
+      };
+      return `${argName}:$${varName}`;
+    });
+    return `(${argStrings})${parseRequest(fields, ctx, path)}`;
+  } else if (typeof request === "object" && Object.keys(request).length > 0) {
+    const fields = request;
+    const fieldNames = Object.keys(fields).filter((k) => Boolean(fields[k]));
+    if (fieldNames.length === 0) {
+      throw new Error(
+        `field selection should not be empty: ${path.join(".")}`
+      );
+    }
+    const type = path.length > 0 ? getFieldFromPath(ctx.root, path).type : ctx.root;
+    const scalarFields = type.scalar;
+    let scalarFieldsFragment;
+    if (fieldNames.includes("__scalar")) {
+      const falsyFieldNames = new Set(
+        Object.keys(fields).filter((k) => !Boolean(fields[k]))
+      );
+      if (scalarFields?.length) {
+        ctx.fragmentCounter++;
+        scalarFieldsFragment = `f${ctx.fragmentCounter}`;
+        ctx.fragments.push(
+          `fragment ${scalarFieldsFragment} on ${type.name}{${scalarFields.filter((f) => !falsyFieldNames.has(f)).join(",")}}`
+        );
+      }
+    }
+    const fieldsSelection = fieldNames.filter((f) => !["__scalar", "__name"].includes(f)).map((f) => {
+      const parsed = parseRequest(fields[f], ctx, [...path, f]);
+      if (f.startsWith("on_")) {
+        ctx.fragmentCounter++;
+        const implementationFragment = `f${ctx.fragmentCounter}`;
+        const typeMatch = f.match(/^on_(.+)/);
+        if (!typeMatch || !typeMatch[1])
+          throw new Error("match failed");
+        ctx.fragments.push(
+          `fragment ${implementationFragment} on ${typeMatch[1]}${parsed}`
+        );
+        return `...${implementationFragment}`;
+      } else {
+        return `${f}${parsed}`;
+      }
+    }).concat(scalarFieldsFragment ? [`...${scalarFieldsFragment}`] : []).join(",");
+    return `{${fieldsSelection}}`;
+  } else {
+    return "";
+  }
+};
+var generateGraphqlOperation = (operation, root, fields) => {
+  const ctx = {
+    root,
+    varCounter: 0,
+    variables: {},
+    fragmentCounter: 0,
+    fragments: []
+  };
+  const result = parseRequest(fields, ctx, []);
+  const varNames = Object.keys(ctx.variables);
+  const varsString = varNames.length > 0 ? `(${varNames.map((v) => {
+    const variableType = ctx.variables[v].typing[1];
+    return `$${v}:${variableType}`;
+  })})` : "";
+  const operationName = fields?.__name || "";
+  return {
+    query: [
+      `${operation} ${operationName}${varsString}${result}`,
+      ...ctx.fragments
+    ].join(","),
+    variables: Object.keys(ctx.variables).reduce(
+      (r, v) => {
+        r[v] = ctx.variables[v].value;
+        return r;
+      },
+      {}
+    ),
+    ...operationName ? { operationName: operationName.toString() } : {}
+  };
+};
+var getFieldFromPath = (root, path) => {
+  let current;
+  if (!root) throw new Error("root type is not provided");
+  if (path.length === 0) throw new Error(`path is empty`);
+  path.forEach((f) => {
+    const type = current ? current.type : root;
+    if (!type.fields)
+      throw new Error(`type \`${type.name}\` does not have fields`);
+    const possibleTypes = Object.keys(type.fields).filter((i) => i.startsWith("on_")).reduce(
+      (types, fieldName) => {
+        const field2 = type.fields && type.fields[fieldName];
+        if (field2) types.push(field2.type);
+        return types;
+      },
+      [type]
+    );
+    let field = null;
+    possibleTypes.forEach((type2) => {
+      const found = type2.fields && type2.fields[f];
+      if (found) field = found;
+    });
+    if (!field)
+      throw new Error(
+        `type \`${type.name}\` does not have a field \`${f}\``
+      );
+    current = field;
+  });
+  return current;
+};
+
+// generated/runtime/createClient.ts
+var createClient = ({
+  queryRoot,
+  mutationRoot,
+  subscriptionRoot,
+  ...options
+}) => {
+  const fetcher = createFetcher(options);
+  const client = {};
+  if (queryRoot) {
+    client.query = (request) => {
+      if (!queryRoot) throw new Error("queryRoot argument is missing");
+      const resultPromise = fetcher(
+        generateGraphqlOperation("query", queryRoot, request)
+      );
+      return resultPromise;
+    };
+  }
+  if (mutationRoot) {
+    client.mutation = (request) => {
+      if (!mutationRoot)
+        throw new Error("mutationRoot argument is missing");
+      const resultPromise = fetcher(
+        generateGraphqlOperation("mutation", mutationRoot, request)
+      );
+      return resultPromise;
+    };
+  }
+  return client;
+};
+
+// generated/runtime/linkTypeMap.ts
+var linkTypeMap = (typeMap2) => {
+  const indexToName = Object.assign(
+    {},
+    ...Object.keys(typeMap2.types).map((k, i) => ({ [i]: k }))
+  );
+  let intermediaryTypeMap = Object.assign(
+    {},
+    ...Object.keys(typeMap2.types || {}).map(
+      (k) => {
+        const type = typeMap2.types[k];
+        const fields = type || {};
+        return {
+          [k]: {
+            name: k,
+            // type scalar properties
+            scalar: Object.keys(fields).filter((f) => {
+              const [type2] = fields[f] || [];
+              const isScalar = type2 && typeMap2.scalars.includes(type2);
+              if (!isScalar) {
+                return false;
+              }
+              const args = fields[f]?.[1];
+              const argTypes = Object.values(args || {}).map((x) => x?.[1]).filter(Boolean);
+              const hasRequiredArgs = argTypes.some(
+                (str) => str && str.endsWith("!")
+              );
+              if (hasRequiredArgs) {
+                return false;
+              }
+              return true;
+            }),
+            // fields with corresponding `type` and `args`
+            fields: Object.assign(
+              {},
+              ...Object.keys(fields).map(
+                (f) => {
+                  const [typeIndex, args] = fields[f] || [];
+                  if (typeIndex == null) {
+                    return {};
+                  }
+                  return {
+                    [f]: {
+                      // replace index with type name
+                      type: indexToName[typeIndex],
+                      args: Object.assign(
+                        {},
+                        ...Object.keys(args || {}).map(
+                          (k2) => {
+                            if (!args || !args[k2]) {
+                              return;
+                            }
+                            const [
+                              argTypeName,
+                              argTypeString
+                            ] = args[k2];
+                            return {
+                              [k2]: [
+                                indexToName[argTypeName],
+                                argTypeString || indexToName[argTypeName]
+                              ]
+                            };
+                          }
+                        )
+                      )
+                    }
+                  };
+                }
+              )
+            )
+          }
+        };
+      }
+    )
+  );
+  const res = resolveConcreteTypes(intermediaryTypeMap);
+  return res;
+};
+var resolveConcreteTypes = (linkedTypeMap) => {
+  Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
+    const type = linkedTypeMap[typeNameFromKey];
+    if (!type.fields) {
+      return;
+    }
+    const fields = type.fields;
+    Object.keys(fields).forEach((f) => {
+      const field = fields[f];
+      if (field.args) {
+        const args = field.args;
+        Object.keys(args).forEach((key) => {
+          const arg = args[key];
+          if (arg) {
+            const [typeName2] = arg;
+            if (typeof typeName2 === "string") {
+              if (!linkedTypeMap[typeName2]) {
+                linkedTypeMap[typeName2] = { name: typeName2 };
+              }
+              arg[0] = linkedTypeMap[typeName2];
+            }
+          }
+        });
+      }
+      const typeName = field.type;
+      if (typeof typeName === "string") {
+        if (!linkedTypeMap[typeName]) {
+          linkedTypeMap[typeName] = { name: typeName };
+        }
+        field.type = linkedTypeMap[typeName];
+      }
+    });
+  });
+  return linkedTypeMap;
+};
+
+// generated/types.ts
+var types_default = {
+  "scalars": [
+    0,
+    3,
+    7,
+    8,
+    14,
+    17,
+    19,
+    20,
+    21,
+    22,
+    24,
+    28,
+    29,
+    38,
+    39,
+    42,
+    45
+  ],
+  "types": {
+    "ApplicationStatus": {},
+    "ApplyToClanInput": {
+      "clan_id": [
+        42
+      ],
+      "motivation_text": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "AssignUnitInput": {
+      "pool_id": [
+        42
+      ],
+      "unit_ids": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Boolean": {},
+    "Clan": {
+      "created_at": [
+        14
+      ],
+      "created_at_tick": [
+        21
+      ],
+      "description": [
+        42
+      ],
+      "governance_type": [
+        19
+      ],
+      "id": [
+        20
+      ],
+      "leader_claw_id": [
+        42
+      ],
+      "membership_policy": [
+        22
+      ],
+      "name": [
+        42
+      ],
+      "status": [
+        8
+      ],
+      "tax_rate": [
+        17
+      ],
+      "treasury_food": [
+        17
+      ],
+      "treasury_minerals": [
+        17
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "ClanApplication": {
+      "clan_id": [
+        42
+      ],
+      "claw_id": [
+        42
+      ],
+      "created_at": [
+        14
+      ],
+      "id": [
+        20
+      ],
+      "motivation_text": [
+        42
+      ],
+      "status": [
+        0
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "ClanPact": {
+      "created_at": [
+        14
+      ],
+      "duration_ticks": [
+        21
+      ],
+      "id": [
+        20
+      ],
+      "proposer_clan_id": [
+        42
+      ],
+      "status": [
+        24
+      ],
+      "target_clan_id": [
+        42
+      ],
+      "ticks_remaining": [
+        21
+      ],
+      "type": [
+        7
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "ClanPactType": {},
+    "ClanStatus": {},
+    "Claw": {
+      "aggression": [
+        17
+      ],
+      "bio": [
+        42
+      ],
+      "created_at": [
+        14
+      ],
+      "deception": [
+        17
+      ],
+      "food": [
+        17
+      ],
+      "id": [
+        20
+      ],
+      "is_alive": [
+        3
+      ],
+      "is_molting": [
+        3
+      ],
+      "level": [
+        21
+      ],
+      "loyalty": [
+        17
+      ],
+      "minerals": [
+        17
+      ],
+      "molt_ticks_remaining": [
+        21
+      ],
+      "name": [
+        42
+      ],
+      "profile_emoji": [
+        42
+      ],
+      "scent": [
+        21
+      ],
+      "shell_tier": [
+        21
+      ],
+      "soft_shell_curse_ticks_remaining": [
+        21
+      ],
+      "species": [
+        39
+      ],
+      "territoriality": [
+        17
+      ],
+      "webhook_url": [
+        42
+      ],
+      "xp": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "ClawSummary": {
+      "id": [
+        20
+      ],
+      "is_alive": [
+        3
+      ],
+      "name": [
+        42
+      ],
+      "species": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "CreateClanInput": {
+      "description": [
+        42
+      ],
+      "governance_type": [
+        19
+      ],
+      "membership_policy": [
+        22
+      ],
+      "name": [
+        42
+      ],
+      "tax_rate": [
+        17
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "CreateClawInput": {
+      "aggression": [
+        17
+      ],
+      "bio": [
+        42
+      ],
+      "deception": [
+        17
+      ],
+      "loyalty": [
+        17
+      ],
+      "name": [
+        42
+      ],
+      "profile_emoji": [
+        42
+      ],
+      "species": [
+        39
+      ],
+      "territoriality": [
+        17
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "CreateClawPayload": {
+      "api_key": [
+        42
+      ],
+      "claw": [
+        9
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "DateTime": {},
+    "DeploySpyInput": {
+      "target_claw_id": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "DismissUnitInput": {
+      "count": [
+        21
+      ],
+      "unit_id": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Float": {},
+    "GameEvent": {
+      "claw_id": [
+        42
+      ],
+      "data": [
+        42
+      ],
+      "event_type": [
+        42
+      ],
+      "id": [
+        20
+      ],
+      "pool_id": [
+        42
+      ],
+      "region_id": [
+        21
+      ],
+      "target_claw_id": [
+        42
+      ],
+      "tick": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "GovernanceType": {},
+    "ID": {},
+    "Int": {},
+    "MembershipPolicy": {},
+    "Mutation": {
+      "acceptClanPact": [
+        6,
+        {
+          "pactId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "applyToClan": [
+        5,
+        {
+          "input": [
+            1,
+            "ApplyToClanInput!"
+          ]
+        }
+      ],
+      "assign_units": [
+        44,
+        {
+          "input": [
+            2,
+            "AssignUnitInput!"
+          ]
+        }
+      ],
+      "breakClanPact": [
+        6,
+        {
+          "pactId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "cancelApplication": [
+        5,
+        {
+          "applicationId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "createClan": [
+        4,
+        {
+          "input": [
+            11,
+            "CreateClanInput!"
+          ]
+        }
+      ],
+      "createClaw": [
+        13,
+        {
+          "input": [
+            12,
+            "CreateClawInput!"
+          ]
+        }
+      ],
+      "deploy_spy": [
+        40,
+        {
+          "input": [
+            15,
+            "DeploySpyInput!"
+          ]
+        }
+      ],
+      "dismiss_units": [
+        44,
+        {
+          "input": [
+            16,
+            "DismissUnitInput!"
+          ]
+        }
+      ],
+      "dissolveClan": [
+        4
+      ],
+      "initiate_siege": [
+        37,
+        {
+          "attacker_pool_id": [
+            42,
+            "String!"
+          ],
+          "defender_pool_id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "kickMember": [
+        9,
+        {
+          "clawId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "leaveClan": [
+        9
+      ],
+      "proposeClanPact": [
+        6,
+        {
+          "input": [
+            30,
+            "ProposeClanPactInput!"
+          ]
+        }
+      ],
+      "recruit_units": [
+        44,
+        {
+          "input": [
+            33,
+            "RecruitUnitInput!"
+          ]
+        }
+      ],
+      "regenerateClawKey": [
+        34,
+        {
+          "clawId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "reviewApplication": [
+        5,
+        {
+          "accept": [
+            3,
+            "Boolean!"
+          ],
+          "applicationId": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "send_whisper": [
+        47,
+        {
+          "input": [
+            36,
+            "SendWhisperInput!"
+          ]
+        }
+      ],
+      "signIn": [
+        25
+      ],
+      "updateDirectives": [
+        41,
+        {
+          "input": [
+            46,
+            "UpdateDirectivesInput!"
+          ]
+        }
+      ],
+      "withdraw_siege": [
+        37,
+        {
+          "siege_id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "PactStatus": {},
+    "Player": {
+      "avatar_url": [
+        42
+      ],
+      "created_at": [
+        14
+      ],
+      "display_name": [
+        42
+      ],
+      "email": [
+        42
+      ],
+      "id": [
+        20
+      ],
+      "onboarding_finalized_at": [
+        14
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "PlayerProfile": {
+      "claws": [
+        10
+      ],
+      "player": [
+        25
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Pool": {
+      "fortification": [
+        21
+      ],
+      "id": [
+        20
+      ],
+      "is_spawn_zone": [
+        3
+      ],
+      "owner_claw_id": [
+        42
+      ],
+      "q": [
+        21
+      ],
+      "r": [
+        21
+      ],
+      "region_id": [
+        21
+      ],
+      "type": [
+        28
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "PoolType": {},
+    "PrimaryGoal": {},
+    "ProposeClanPactInput": {
+      "duration_ticks": [
+        21
+      ],
+      "target_clan_id": [
+        42
+      ],
+      "type": [
+        7
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "PublicClaw": {
+      "bio": [
+        42
+      ],
+      "id": [
+        20
+      ],
+      "is_alive": [
+        3
+      ],
+      "level": [
+        21
+      ],
+      "name": [
+        42
+      ],
+      "profile_emoji": [
+        42
+      ],
+      "scent": [
+        21
+      ],
+      "shell_tier": [
+        21
+      ],
+      "species": [
+        39
+      ],
+      "xp": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Query": {
+      "clan": [
+        4,
+        {
+          "id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "clanApplications": [
+        5
+      ],
+      "clanPacts": [
+        6
+      ],
+      "clans": [
+        4
+      ],
+      "claw": [
+        31,
+        {
+          "id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "claws": [
+        31,
+        {
+          "limit": [
+            21,
+            "Int!"
+          ],
+          "offset": [
+            21,
+            "Int!"
+          ]
+        }
+      ],
+      "events": [
+        18,
+        {
+          "clawId": [
+            42
+          ],
+          "eventType": [
+            42
+          ],
+          "limit": [
+            21,
+            "Int!"
+          ],
+          "offset": [
+            21,
+            "Int!"
+          ],
+          "regionId": [
+            21
+          ],
+          "tick": [
+            21
+          ]
+        }
+      ],
+      "inbox": [
+        47,
+        {
+          "limit": [
+            21,
+            "Int!"
+          ],
+          "offset": [
+            21,
+            "Int!"
+          ]
+        }
+      ],
+      "intercepted_whispers": [
+        47
+      ],
+      "me": [
+        26
+      ],
+      "myApplications": [
+        5
+      ],
+      "myClan": [
+        4
+      ],
+      "myDirectives": [
+        41
+      ],
+      "myProfile": [
+        9
+      ],
+      "myRelationships": [
+        35
+      ],
+      "my_sieges": [
+        37
+      ],
+      "my_spy_deployments": [
+        40
+      ],
+      "my_units": [
+        44
+      ],
+      "outbox": [
+        47,
+        {
+          "limit": [
+            21,
+            "Int!"
+          ],
+          "offset": [
+            21,
+            "Int!"
+          ]
+        }
+      ],
+      "pool": [
+        27,
+        {
+          "id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "pool_units": [
+        44,
+        {
+          "pool_id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "pools": [
+        27,
+        {
+          "clawId": [
+            42
+          ]
+        }
+      ],
+      "siege": [
+        37,
+        {
+          "id": [
+            42,
+            "String!"
+          ]
+        }
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "RecruitUnitInput": {
+      "count": [
+        21
+      ],
+      "type": [
+        45
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "RegenerateKeyPayload": {
+      "api_key": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Relationship": {
+      "battles": [
+        21
+      ],
+      "betrayals": [
+        21
+      ],
+      "claw_id": [
+        42
+      ],
+      "encounters": [
+        21
+      ],
+      "id": [
+        20
+      ],
+      "other_claw_id": [
+        42
+      ],
+      "trust_score": [
+        17
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "SendWhisperInput": {
+      "content": [
+        42
+      ],
+      "receiver_id": [
+        42
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Siege": {
+      "attacker_claw_id": [
+        42
+      ],
+      "attacker_pool_id": [
+        42
+      ],
+      "created_at": [
+        14
+      ],
+      "defender_claw_id": [
+        42
+      ],
+      "defender_pool_id": [
+        42
+      ],
+      "ended_at_tick": [
+        21
+      ],
+      "id": [
+        20
+      ],
+      "started_at_tick": [
+        21
+      ],
+      "status": [
+        38
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "SiegeStatus": {},
+    "Species": {},
+    "SpyDeployment": {
+      "created_at": [
+        14
+      ],
+      "id": [
+        20
+      ],
+      "is_detected": [
+        3
+      ],
+      "owner_claw_id": [
+        42
+      ],
+      "started_at_tick": [
+        21
+      ],
+      "target_claw_id": [
+        42
+      ],
+      "ticks_remaining": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "StandingOrder": {
+      "aggression_stance": [
+        17
+      ],
+      "claw_id": [
+        42
+      ],
+      "diplomacy_stance": [
+        17
+      ],
+      "id": [
+        20
+      ],
+      "primary_goal": [
+        29
+      ],
+      "target_claw_id": [
+        42
+      ],
+      "target_region_id": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "String": {},
+    "Subscription": {
+      "tickEvents": [
+        18
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Unit": {
+      "claw_id": [
+        42
+      ],
+      "count": [
+        21
+      ],
+      "id": [
+        20
+      ],
+      "pool_id": [
+        42
+      ],
+      "type": [
+        45
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "UnitType": {},
+    "UpdateDirectivesInput": {
+      "aggression_stance": [
+        17
+      ],
+      "diplomacy_stance": [
+        17
+      ],
+      "exclusions": [
+        42
+      ],
+      "primary_goal": [
+        29
+      ],
+      "target_claw_id": [
+        42
+      ],
+      "target_region_id": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    },
+    "Whisper": {
+      "content": [
+        42
+      ],
+      "created_at": [
+        14
+      ],
+      "id": [
+        20
+      ],
+      "receiver_id": [
+        42
+      ],
+      "sender_id": [
+        42
+      ],
+      "tick": [
+        21
+      ],
+      "__typename": [
+        42
+      ]
+    }
+  }
+};
+
+// generated/schema.ts
+var Clan_possibleTypes = ["Clan"];
+var isClan = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isClan"');
+  return Clan_possibleTypes.includes(obj.__typename);
+};
+var ClanApplication_possibleTypes = ["ClanApplication"];
+var isClanApplication = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isClanApplication"');
+  return ClanApplication_possibleTypes.includes(obj.__typename);
+};
+var ClanPact_possibleTypes = ["ClanPact"];
+var isClanPact = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isClanPact"');
+  return ClanPact_possibleTypes.includes(obj.__typename);
+};
+var Claw_possibleTypes = ["Claw"];
+var isClaw = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isClaw"');
+  return Claw_possibleTypes.includes(obj.__typename);
+};
+var ClawSummary_possibleTypes = ["ClawSummary"];
+var isClawSummary = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isClawSummary"');
+  return ClawSummary_possibleTypes.includes(obj.__typename);
+};
+var CreateClawPayload_possibleTypes = ["CreateClawPayload"];
+var isCreateClawPayload = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isCreateClawPayload"');
+  return CreateClawPayload_possibleTypes.includes(obj.__typename);
+};
+var GameEvent_possibleTypes = ["GameEvent"];
+var isGameEvent = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isGameEvent"');
+  return GameEvent_possibleTypes.includes(obj.__typename);
+};
+var Mutation_possibleTypes = ["Mutation"];
+var isMutation = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isMutation"');
+  return Mutation_possibleTypes.includes(obj.__typename);
+};
+var Player_possibleTypes = ["Player"];
+var isPlayer = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isPlayer"');
+  return Player_possibleTypes.includes(obj.__typename);
+};
+var PlayerProfile_possibleTypes = ["PlayerProfile"];
+var isPlayerProfile = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isPlayerProfile"');
+  return PlayerProfile_possibleTypes.includes(obj.__typename);
+};
+var Pool_possibleTypes = ["Pool"];
+var isPool = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isPool"');
+  return Pool_possibleTypes.includes(obj.__typename);
+};
+var PublicClaw_possibleTypes = ["PublicClaw"];
+var isPublicClaw = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isPublicClaw"');
+  return PublicClaw_possibleTypes.includes(obj.__typename);
+};
+var Query_possibleTypes = ["Query"];
+var isQuery = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isQuery"');
+  return Query_possibleTypes.includes(obj.__typename);
+};
+var RegenerateKeyPayload_possibleTypes = ["RegenerateKeyPayload"];
+var isRegenerateKeyPayload = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isRegenerateKeyPayload"');
+  return RegenerateKeyPayload_possibleTypes.includes(obj.__typename);
+};
+var Relationship_possibleTypes = ["Relationship"];
+var isRelationship = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isRelationship"');
+  return Relationship_possibleTypes.includes(obj.__typename);
+};
+var Siege_possibleTypes = ["Siege"];
+var isSiege = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isSiege"');
+  return Siege_possibleTypes.includes(obj.__typename);
+};
+var SpyDeployment_possibleTypes = ["SpyDeployment"];
+var isSpyDeployment = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isSpyDeployment"');
+  return SpyDeployment_possibleTypes.includes(obj.__typename);
+};
+var StandingOrder_possibleTypes = ["StandingOrder"];
+var isStandingOrder = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isStandingOrder"');
+  return StandingOrder_possibleTypes.includes(obj.__typename);
+};
+var Subscription_possibleTypes = ["Subscription"];
+var isSubscription = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isSubscription"');
+  return Subscription_possibleTypes.includes(obj.__typename);
+};
+var Unit_possibleTypes = ["Unit"];
+var isUnit = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isUnit"');
+  return Unit_possibleTypes.includes(obj.__typename);
+};
+var Whisper_possibleTypes = ["Whisper"];
+var isWhisper = (obj) => {
+  if (!obj?.__typename) throw new Error('__typename is missing in "isWhisper"');
+  return Whisper_possibleTypes.includes(obj.__typename);
+};
+var enumApplicationStatus = {
+  ACCEPTED: "ACCEPTED",
+  PENDING: "PENDING",
+  REJECTED: "REJECTED"
+};
+var enumClanPactType = {
+  MILITARY_ALLIANCE: "MILITARY_ALLIANCE",
+  NON_AGGRESSION: "NON_AGGRESSION"
+};
+var enumClanStatus = {
+  ACTIVE: "ACTIVE",
+  DISSOLVED: "DISSOLVED"
+};
+var enumGovernanceType = {
+  AUTOCRACY: "AUTOCRACY",
+  COUNCIL: "COUNCIL",
+  DEMOCRACY: "DEMOCRACY"
+};
+var enumMembershipPolicy = {
+  APPLICATION: "APPLICATION",
+  CLOSED: "CLOSED",
+  FULLY_OPEN: "FULLY_OPEN",
+  INVITATION_ONLY: "INVITATION_ONLY"
+};
+var enumPactStatus = {
+  ACTIVE: "ACTIVE",
+  BROKEN: "BROKEN",
+  EXPIRED: "EXPIRED",
+  PROPOSED: "PROPOSED"
+};
+var enumPoolType = {
+  KELP_FOREST: "KELP_FOREST",
+  REEF: "REEF",
+  SHALLOWS: "SHALLOWS",
+  SPAWNING_GROUND: "SPAWNING_GROUND",
+  TRENCH: "TRENCH"
+};
+var enumPrimaryGoal = {
+  ATTACK: "ATTACK",
+  DEFEND: "DEFEND",
+  EXPAND: "EXPAND",
+  FORTIFY: "FORTIFY",
+  IDLE: "IDLE",
+  MOLT: "MOLT",
+  SPY: "SPY"
+};
+var enumSiegeStatus = {
+  ACTIVE: "ACTIVE",
+  FAILED: "FAILED",
+  WITHDRAWN: "WITHDRAWN",
+  WON: "WON"
+};
+var enumSpecies = {
+  COCONUT_CRAB: "COCONUT_CRAB",
+  HERMIT_CRAB: "HERMIT_CRAB",
+  KING_CRAB: "KING_CRAB",
+  LOBSTER: "LOBSTER",
+  MANTIS_SHRIMP: "MANTIS_SHRIMP",
+  PISTOL_SHRIMP: "PISTOL_SHRIMP"
+};
+var enumUnitType = {
+  BUILDER: "BUILDER",
+  FIGHTER: "FIGHTER",
+  HARVESTER: "HARVESTER",
+  SPY: "SPY"
+};
+
+// generated/index.ts
+var typeMap = linkTypeMap(types_default);
+var createClient2 = function(options) {
+  return createClient({
+    url: void 0,
+    ...options,
+    queryRoot: typeMap.Query,
+    mutationRoot: typeMap.Mutation,
+    subscriptionRoot: typeMap.Subscription
+  });
+};
+var everything = {
+  __scalar: true
+};
+var generateQueryOp = function(fields) {
+  return generateGraphqlOperation("query", typeMap.Query, fields);
+};
+var generateMutationOp = function(fields) {
+  return generateGraphqlOperation("mutation", typeMap.Mutation, fields);
+};
+var generateSubscriptionOp = function(fields) {
+  return generateGraphqlOperation(
+    "subscription",
+    typeMap.Subscription,
+    fields
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenqlError,
+  createClient,
+  enumApplicationStatus,
+  enumClanPactType,
+  enumClanStatus,
+  enumGovernanceType,
+  enumMembershipPolicy,
+  enumPactStatus,
+  enumPoolType,
+  enumPrimaryGoal,
+  enumSiegeStatus,
+  enumSpecies,
+  enumUnitType,
+  everything,
+  generateMutationOp,
+  generateQueryOp,
+  generateSubscriptionOp,
+  isClan,
+  isClanApplication,
+  isClanPact,
+  isClaw,
+  isClawSummary,
+  isCreateClawPayload,
+  isGameEvent,
+  isMutation,
+  isPlayer,
+  isPlayerProfile,
+  isPool,
+  isPublicClaw,
+  isQuery,
+  isRegenerateKeyPayload,
+  isRelationship,
+  isSiege,
+  isSpyDeployment,
+  isStandingOrder,
+  isSubscription,
+  isUnit,
+  isWhisper
+});