@itm-studio/partner-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1098 @@
+'use strict';
+
+// src/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;
+  }
+};
+
+// src/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;
+  }
+};
+
+// src/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)
+    );
+  };
+};
+
+// src/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;
+};
+
+// src/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;
+};
+
+// src/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;
+};
+
+// src/generated/types.ts
+var types_default = {
+  "scalars": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    9,
+    10,
+    13,
+    14,
+    16
+  ],
+  "types": {
+    "DateTime": {},
+    "MomentStatus": {},
+    "MomentSortOrder": {},
+    "MomentType": {},
+    "MomentCategory": {},
+    "MomentSubcategory": {},
+    "PaymentStatus": {},
+    "TicketExtensionStatus": {},
+    "Currency": {
+      "uid": [
+        9
+      ],
+      "code": [
+        10
+      ],
+      "name": [
+        10
+      ],
+      "symbol": [
+        10
+      ],
+      "country": [
+        10
+      ],
+      "countryCode": [
+        10
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "ID": {},
+    "String": {},
+    "Venue": {
+      "uid": [
+        9
+      ],
+      "name": [
+        10
+      ],
+      "address": [
+        10
+      ],
+      "city": [
+        10
+      ],
+      "country": [
+        10
+      ],
+      "postalCode": [
+        10
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Moment": {
+      "uid": [
+        9
+      ],
+      "name": [
+        10
+      ],
+      "description": [
+        10
+      ],
+      "blurb": [
+        10
+      ],
+      "slug": [
+        10
+      ],
+      "startDate": [
+        0
+      ],
+      "endDate": [
+        0
+      ],
+      "isPrivate": [
+        13
+      ],
+      "type": [
+        3
+      ],
+      "category": [
+        4
+      ],
+      "subcategory": [
+        5
+      ],
+      "status": [
+        1
+      ],
+      "soldOut": [
+        13
+      ],
+      "timezone": [
+        10
+      ],
+      "minimumAge": [
+        14
+      ],
+      "venue": [
+        11
+      ],
+      "ticketTiers": [
+        15
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Boolean": {},
+    "Int": {},
+    "TicketTier": {
+      "uid": [
+        9
+      ],
+      "name": [
+        10
+      ],
+      "description": [
+        10
+      ],
+      "price": [
+        16
+      ],
+      "currency": [
+        8
+      ],
+      "isActive": [
+        13
+      ],
+      "isPrivate": [
+        13
+      ],
+      "maxPerUser": [
+        14
+      ],
+      "minPerUser": [
+        14
+      ],
+      "remainingSupply": [
+        14
+      ],
+      "numSold": [
+        16
+      ],
+      "numCheckedIn": [
+        16
+      ],
+      "startDateOverride": [
+        0
+      ],
+      "endDateOverride": [
+        0
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Float": {},
+    "User": {
+      "uid": [
+        9
+      ],
+      "name": [
+        10
+      ],
+      "phoneNumber": [
+        10
+      ],
+      "primaryEmail": [
+        10
+      ],
+      "instagramProfile": [
+        10
+      ],
+      "twitterProfile": [
+        10
+      ],
+      "spotifyProfile": [
+        10
+      ],
+      "tiktokProfile": [
+        10
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Ticket": {
+      "uid": [
+        9
+      ],
+      "price": [
+        16
+      ],
+      "redeemedAt": [
+        0
+      ],
+      "encryptedQRCode": [
+        10
+      ],
+      "notes": [
+        10
+      ],
+      "externalId": [
+        10
+      ],
+      "hasExpired": [
+        13
+      ],
+      "ticketTier": [
+        15
+      ],
+      "user": [
+        17
+      ],
+      "moment": [
+        12
+      ],
+      "payment": [
+        21
+      ],
+      "extensions": [
+        19
+      ],
+      "discountCodeUsages": [
+        20
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "TicketExtension": {
+      "uid": [
+        9
+      ],
+      "hours": [
+        14
+      ],
+      "previousTotalHours": [
+        14
+      ],
+      "newTotalHours": [
+        14
+      ],
+      "pricePerHourCents": [
+        14
+      ],
+      "totalPriceCents": [
+        14
+      ],
+      "status": [
+        7
+      ],
+      "appliedAt": [
+        0
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "MomentDiscountCodeUsage": {
+      "uid": [
+        9
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Payment": {
+      "uid": [
+        9
+      ],
+      "amount": [
+        16
+      ],
+      "status": [
+        6
+      ],
+      "stripePaymentIntentId": [
+        10
+      ],
+      "stripeConnectedPaymentId": [
+        10
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "MerchPurchase": {
+      "uid": [
+        9
+      ],
+      "createdAt": [
+        0
+      ],
+      "updatedAt": [
+        0
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "PartnerCustomer": {
+      "user": [
+        17
+      ],
+      "tickets": [
+        18
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "GetPublicMomentsResponse": {
+      "moments": [
+        12
+      ],
+      "totalCount": [
+        14
+      ],
+      "hasNextPage": [
+        13
+      ],
+      "nextCursor": [
+        10
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "GetTicketsResponse": {
+      "tickets": [
+        18
+      ],
+      "totalCount": [
+        14
+      ],
+      "hasNextPage": [
+        13
+      ],
+      "nextCursor": [
+        10
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "GetPartnerCustomersResponse": {
+      "customers": [
+        23
+      ],
+      "totalCount": [
+        14
+      ],
+      "hasNextPage": [
+        13
+      ],
+      "nextCursor": [
+        10
+      ],
+      "__typename": [
+        10
+      ]
+    },
+    "Query": {
+      "getPartnerMomentsForBrand": [
+        24,
+        {
+          "cursor": [
+            10
+          ],
+          "take": [
+            14
+          ],
+          "status": [
+            1
+          ],
+          "sortOrder": [
+            2
+          ]
+        }
+      ],
+      "getPartnerMoment": [
+        12,
+        {
+          "slug": [
+            10,
+            "String!"
+          ]
+        }
+      ],
+      "getPartnerTicketsForMoment": [
+        25,
+        {
+          "momentSlug": [
+            10,
+            "String!"
+          ],
+          "cursor": [
+            10
+          ],
+          "take": [
+            14
+          ],
+          "checkedIn": [
+            13
+          ]
+        }
+      ],
+      "getPartnerCustomersForMoment": [
+        26,
+        {
+          "momentSlug": [
+            10,
+            "String!"
+          ],
+          "cursor": [
+            10
+          ],
+          "take": [
+            14
+          ]
+        }
+      ],
+      "__typename": [
+        10
+      ]
+    }
+  }
+};
+
+// src/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);
+};
+
+// src/client.ts
+function createITMPartnerClient(config) {
+  const { token, baseUrl, headers: extraHeaders } = config;
+  if (!token) {
+    throw new Error(
+      "ITM Partner SDK: token is required. Get one from backstage: Settings > Partner API."
+    );
+  }
+  return createClient2({
+    url: baseUrl ?? "https://api.itm.studio/graphql",
+    headers: {
+      "x-partner-api-key": token,
+      "Content-Type": "application/json",
+      ...extraHeaders
+    }
+  });
+}
+
+exports.createITMPartnerClient = createITMPartnerClient;
+exports.everything = everything;
+exports.generateQueryOp = generateQueryOp;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map