bgg-sdk/dist/index.js

Node SDK for querying the Board Game Geek (BGG) XML2 API

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
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 __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 __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/index.ts
var src_exports = {};
__export(src_exports, {
  ContentTypes: () => contentTypes_exports,
  ParamTypes: () => params_exports,
  PayloadTypes: () => payloads_exports,
  bgg: () => bgg,
  default: () => src_default
});
module.exports = __toCommonJS(src_exports);

// src/lib/axios.ts
var import_axios = __toESM(require("axios"));
var import_axios_retry = __toESM(require("axios-retry"));
var import_xml_js = __toESM(require("xml-js"));
var axios = import_axios.default.create({
  baseURL: "https://boardgamegeek.com/xmlapi2/"
});
(0, import_axios_retry.default)(axios, {
  retries: 3,
  retryDelay: import_axios_retry.default.exponentialDelay
});
axios.interceptors.response.use(
  (response) => {
    try {
      const jsonData = import_xml_js.default.xml2js(response.data, { compact: true });
      response.data = jsonData;
      return response;
    } catch (error) {
      throw new Error("Failed to parse XML data from BGG");
    }
  },
  (error) => {
    return Promise.reject(`Unexpected error calling BGG API: ${error.stack}`);
  }
);

// src/lib/helpers.ts
var enforceArray = (value) => {
  if (!value)
    return [];
  if (Array.isArray(value))
    return value;
  return [value];
};

// src/routes/collection.ts
var transformParams = (params) => {
  var _a;
  return __spreadProps(__spreadValues({}, params), {
    id: (_a = params.id) == null ? void 0 : _a.join(",")
  });
};
var transformData = (data) => {
  if (!data.items) {
    return null;
  }
  return {
    attributes: {
      termsOfUse: data.items._attributes.termsofuse,
      totalItems: data.items._attributes.totalitems,
      pubDate: data.items._attributes.pubdate
    },
    items: enforceArray(data.items.item).map((data2) => {
      var _a, _b, _c;
      return {
        id: data2._attributes.objectid,
        collId: data2._attributes.collid,
        type: data2._attributes.objecttype,
        name: data2.name._text,
        yearPublished: (_a = data2.yearpublished) == null ? void 0 : _a._text,
        image: (_b = data2.image) == null ? void 0 : _b._text,
        thumbnail: (_c = data2.thumbnail) == null ? void 0 : _c._text,
        status: {
          own: data2.status._attributes.own,
          prevOwned: data2.status._attributes.prevowned,
          forTrade: data2.status._attributes.fortrade,
          want: data2.status._attributes.want,
          wantToPlay: data2.status._attributes.wanttoplay,
          wantToBuy: data2.status._attributes.wanttobuy,
          wishList: data2.status._attributes.wishlist,
          preOrdered: data2.status._attributes.preordered,
          lastModified: data2.status._attributes.lastmodified
        },
        numPlays: data2.numplays._text
      };
    })
  };
};
var collection = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/collection", {
    params: transformParams(params)
  });
  return transformData(data);
});

// src/routes/family.ts
var transformParams2 = (params) => {
  var _a;
  return __spreadProps(__spreadValues({}, params), {
    id: params.id.join(","),
    type: (_a = params.type) == null ? void 0 : _a.join(",")
  });
};
var transformData2 = (data) => {
  return {
    attributes: {
      termsOfUse: data.items._attributes.termsofuse
    },
    items: enforceArray(data.items.item).map((data2) => {
      return {
        id: data2._attributes.id,
        type: data2._attributes.type,
        thumbnail: data2.thumbnail._text,
        image: data2.image._text,
        description: data2.description._text,
        names: enforceArray(data2.name).map((name) => ({
          type: name._attributes.type,
          sortIndex: name._attributes.sortindex,
          value: name._attributes.value
        })),
        links: enforceArray(data2.link).map((link) => ({
          type: link._attributes.type,
          id: link._attributes.id,
          value: link._attributes.value,
          inbound: link._attributes.inbound === "true"
        }))
      };
    })
  };
};
var family = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/family", {
    params: transformParams2(params)
  });
  return transformData2(data);
});

// src/routes/forum.ts
var transformData3 = (data) => {
  return {
    attributes: {
      id: data.forum._attributes.id,
      title: data.forum._attributes.title,
      numThreads: data.forum._attributes.numthreads,
      numPosts: data.forum._attributes.numposts,
      lastPostDate: data.forum._attributes.lastpostdate,
      noPosting: data.forum._attributes.noposting,
      termsOfUse: data.forum._attributes.termsofuse
    },
    threads: enforceArray(data.forum.threads.thread).map((thread2) => ({
      id: thread2._attributes.id,
      subject: thread2._attributes.subject,
      author: thread2._attributes.author,
      numArticles: thread2._attributes.numarticles,
      postDate: thread2._attributes.postdate,
      lastPostDate: thread2._attributes.lastpostdate
    }))
  };
};
var forum = (params) => __async(void 0, null, function* () {
  try {
    const { data } = yield axios.get("/forum", {
      params
    });
    return transformData3(data);
  } catch (error) {
    return null;
  }
});

// src/routes/forumList.ts
var transformData4 = (data) => {
  return {
    attributes: {
      type: data.forums._attributes.type,
      termsOfUse: data.forums._attributes.termsofuse,
      id: data.forums._attributes.id
    },
    forums: enforceArray(data.forums.forum).map((forum2) => ({
      id: forum2._attributes.id,
      groupId: forum2._attributes.groupid,
      title: forum2._attributes.title,
      noPosting: forum2._attributes.noposting,
      description: forum2._attributes.description,
      numThreads: forum2._attributes.numthreads,
      numPosts: forum2._attributes.numposts,
      lastPostDate: forum2._attributes.lastpostdate
    }))
  };
};
var forumList = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/forumlist", {
    params
  });
  return transformData4(data);
});

// src/routes/guild.ts
var transformData5 = (data) => {
  if ("error" in data.guild) {
    return {
      attributes: {
        termsOfUse: data.guild._attributes.termsofuse
      },
      guild: null
    };
  }
  return {
    attributes: {
      termsOfUse: data.guild._attributes.termsofuse,
      id: data.guild._attributes.id,
      name: data.guild._attributes.name,
      created: data.guild._attributes.created
    },
    guild: {
      id: data.guild._attributes.id,
      name: data.guild._attributes.name,
      created: data.guild._attributes.created,
      category: data.guild.category._text,
      website: data.guild.website._text,
      manager: data.guild.manager._text,
      description: data.guild.description._text,
      location: {
        addr1: data.guild.location.addr1._text,
        addr2: data.guild.location.addr2._text,
        city: data.guild.location.city._text,
        stateorprovince: data.guild.location.stateorprovince._text,
        postalcode: data.guild.location.postalcode._text,
        country: data.guild.location.country._text
      },
      members: data.guild.members && {
        count: data.guild.members._attributes.count,
        page: data.guild.members._attributes.page,
        member: enforceArray(data.guild.members.member).map((member) => ({
          name: member._attributes.name,
          date: member._attributes.date
        }))
      }
    }
  };
};
var guild = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/guild", {
    params
  });
  return transformData5(data);
});

// src/routes/hot.ts
var transformParams3 = (args) => {
  if (!args)
    return void 0;
  return {
    type: args.type.join(",")
  };
};
var transformData6 = (data) => {
  return {
    attributes: {
      termsofuse: data.items._attributes.termsofuse
    },
    items: enforceArray(data.items.item).map((data2) => {
      var _a;
      return {
        id: data2._attributes.id,
        rank: data2._attributes.rank,
        name: data2.name._attributes.value,
        yearPublished: (_a = data2.yearpublished) == null ? void 0 : _a._attributes.value,
        thumbnail: data2.thumbnail._attributes.value
      };
    })
  };
};
var hot = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/hot", {
    params: transformParams3(params)
  });
  return transformData6(data);
});

// src/routes/search.ts
var endpoint = "/search";
var transformParams4 = (args) => {
  return __spreadProps(__spreadValues({}, args), {
    type: args.type ? args.type.join(",") : void 0
  });
};
var transformData7 = (data) => {
  return {
    attributes: {
      termsofuse: data.items._attributes.termsofuse
    },
    items: enforceArray(data.items.item).map((data2) => {
      var _a;
      return {
        id: data2._attributes.id,
        type: data2._attributes.type,
        name: data2.name._attributes.value,
        yearPublished: (_a = data2.yearpublished) == null ? void 0 : _a._attributes.value
      };
    })
  };
};
var search = (args) => __async(void 0, null, function* () {
  const params = transformParams4(args);
  const { data } = yield axios.get(endpoint, { params });
  return transformData7(data);
});

// src/routes/thing.ts
var endpoint2 = "/thing";
var transformParams5 = (args) => {
  var _a;
  return __spreadProps(__spreadValues({}, args), {
    id: args.id.join(","),
    type: (_a = args.type) == null ? void 0 : _a.join(",")
  });
};
var transformPollLanguageDependence = (poll) => {
  return {
    name: poll._attributes.name,
    title: poll._attributes.title,
    totalvotes: poll._attributes.totalvotes,
    results: enforceArray(poll.results.result).map((result) => {
      return {
        level: result._attributes.level,
        value: result._attributes.value,
        numvotes: result._attributes.numvotes
      };
    })
  };
};
var transformPollSuggestedPlayerAge = (poll) => {
  return {
    name: poll._attributes.name,
    title: poll._attributes.title,
    totalvotes: poll._attributes.totalvotes,
    results: enforceArray(poll.results.result).map((result) => {
      return {
        value: result._attributes.value,
        numvotes: result._attributes.numvotes
      };
    })
  };
};
var transformPollSuggestedNumPlayers = (poll) => {
  return {
    name: poll._attributes.name,
    title: poll._attributes.title,
    totalvotes: poll._attributes.totalvotes,
    results: enforceArray(poll.results).map((result) => {
      return {
        numplayers: result._attributes.numplayers,
        result: enforceArray(result.result).map((result2) => {
          return {
            value: result2._attributes.value,
            numvotes: result2._attributes.numvotes
          };
        })
      };
    })
  };
};
var transformPoll = (apiPolls) => {
  const polls = [];
  apiPolls.forEach((apiPoll) => {
    switch (apiPoll._attributes.name) {
      case "language_dependence": {
        polls.push(
          transformPollLanguageDependence(
            apiPoll
          )
        );
        break;
      }
      case "suggested_playerage": {
        polls.push(
          transformPollSuggestedPlayerAge(
            apiPoll
          )
        );
        break;
      }
      case "suggested_numplayers": {
        polls.push(
          transformPollSuggestedNumPlayers(
            apiPoll
          )
        );
        break;
      }
    }
  });
  return polls;
};
var transformData8 = (data) => {
  return {
    attributes: {
      termsofuse: data.items._attributes.termsofuse
    },
    items: enforceArray(data.items.item).map((data2) => {
      var _a, _b;
      return {
        id: data2._attributes.id,
        type: data2._attributes.type,
        thumbnail: (_a = data2.thumbnail) == null ? void 0 : _a._text,
        image: (_b = data2.image) == null ? void 0 : _b._text,
        names: enforceArray(data2.name).map((name) => {
          return {
            type: name._attributes.type,
            sortindex: name._attributes.sortindex,
            value: name._attributes.value
          };
        }),
        description: data2.description._text,
        yearPublished: data2.yearpublished._attributes.value,
        minPlayers: data2.minplayers._attributes.value,
        maxPlayers: data2.maxplayers._attributes.value,
        playingTime: data2.playingtime._attributes.value,
        minPlayTime: data2.minplaytime._attributes.value,
        maxPlayTime: data2.maxplaytime._attributes.value,
        minAge: data2.minage._attributes.value,
        links: enforceArray(data2.link).map((link) => {
          return {
            type: link._attributes.type,
            id: link._attributes.id,
            value: link._attributes.value
          };
        }),
        polls: transformPoll(enforceArray(data2.poll)),
        comments: data2.comments && {
          page: data2.comments._attributes.page,
          total: data2.comments._attributes.totalitems,
          comment: enforceArray(data2.comments.comment).map((comment) => {
            return {
              username: comment._attributes.username,
              rating: comment._attributes.rating,
              value: comment._attributes.value
            };
          })
        },
        marketplace: data2.marketplacelistings && {
          listings: enforceArray(data2.marketplacelistings.listing).map(
            (listing) => {
              return {
                listDate: listing.listdate._attributes.value,
                price: {
                  currency: listing.price._attributes.currency,
                  value: listing.price._attributes.value
                },
                condition: listing.condition._attributes.value,
                notes: listing.notes._attributes.value,
                link: {
                  href: listing.link._attributes.href,
                  title: listing.link._attributes.title
                }
              };
            }
          )
        },
        statistics: data2.statistics && {
          page: data2.statistics._attributes.page,
          ratings: {
            usersRated: data2.statistics.ratings.usersrated._attributes.value,
            average: data2.statistics.ratings.average._attributes.value,
            bayesAverage: data2.statistics.ratings.bayesaverage._attributes.value,
            ranks: enforceArray(data2.statistics.ratings.ranks.rank).map(
              (rank) => {
                return {
                  type: rank._attributes.type,
                  id: rank._attributes.id,
                  name: rank._attributes.name,
                  friendlyName: rank._attributes.friendlyname,
                  value: rank._attributes.value,
                  bayesAverage: rank._attributes.bayesaverage
                };
              }
            )
          },
          stdDev: data2.statistics.ratings.stddev._attributes.value,
          median: data2.statistics.ratings.median._attributes.value,
          owned: data2.statistics.ratings.owned._attributes.value,
          trading: data2.statistics.ratings.trading._attributes.value,
          wanting: data2.statistics.ratings.wanting._attributes.value,
          wishing: data2.statistics.ratings.wishing._attributes.value,
          numComments: data2.statistics.ratings.numcomments._attributes.value,
          numWeights: data2.statistics.ratings.numweights._attributes.value,
          averageWeight: data2.statistics.ratings.averageweight._attributes.value
        },
        versions: data2.versions && enforceArray(data2.versions.item).map((item) => {
          var _a2, _b2;
          return {
            id: item._attributes.id,
            type: item._attributes.type,
            thumbnail: (_a2 = item.thumbnail) == null ? void 0 : _a2._text,
            image: (_b2 = item.image) == null ? void 0 : _b2._text,
            links: enforceArray(item.link).map((link) => {
              return {
                type: link._attributes.type,
                id: link._attributes.id,
                value: link._attributes.value
              };
            }),
            names: enforceArray(item.name).map((name) => {
              return {
                type: name._attributes.type,
                sortindex: name._attributes.sortindex,
                value: name._attributes.value
              };
            }),
            yearPublished: item.yearpublished._attributes.value,
            productCode: item.productcode._attributes.value,
            width: item.width._attributes.value,
            length: item.length._attributes.value,
            depth: item.depth._attributes.value,
            weight: item.weight._attributes.value
          };
        }),
        videos: data2.videos && {
          total: data2.videos._attributes.total,
          videos: enforceArray(data2.videos.video).map((video) => {
            return {
              id: video._attributes.id,
              title: video._attributes.title,
              category: video._attributes.category,
              language: video._attributes.language,
              link: video._attributes.link,
              username: video._attributes.username,
              userid: video._attributes.userid,
              postdate: video._attributes.postdate
            };
          })
        }
      };
    })
  };
};
var thing = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get(endpoint2, {
    params: transformParams5(params)
  });
  return transformData8(data);
});

// src/routes/thread.ts
var endpoint3 = "/thread";
var transformData9 = (data) => {
  if ("error" in data) {
    return null;
  }
  return {
    attributes: {
      id: data.thread._attributes.id,
      numArticles: data.thread._attributes.numarticles,
      link: data.thread._attributes.link,
      termsOfUse: data.thread._attributes.termsofuse
    },
    subject: data.thread.subject._text,
    articles: enforceArray(data.thread.articles.article).map((article) => ({
      id: article._attributes.id,
      username: article._attributes.username,
      link: article._attributes.link,
      postDate: article._attributes.postdate,
      editDate: article._attributes.editdate,
      numEdits: article._attributes.numedits,
      body: article.body._text
    }))
  };
};
var thread = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get(endpoint3, {
    params
  });
  return transformData9(data);
});

// src/routes/user.ts
var endpoint4 = "/user";
var transformData10 = (data) => {
  return {
    termsOfUse: data.user._attributes.termsofuse,
    user: {
      id: data.user._attributes.id,
      name: data.user._attributes.name,
      termsOfUse: data.user._attributes.termsofuse,
      firstName: data.user.firstname._attributes.value,
      lastName: data.user.lastname._attributes.value,
      avatarLink: data.user.avatarlink._attributes.value,
      yearRegistered: data.user.yearregistered._attributes.value,
      lastLogin: data.user.lastlogin._attributes.value,
      stateOrProvince: data.user.stateorprovince._attributes.value,
      country: data.user.country._attributes.value,
      webAddress: data.user.webaddress._attributes.value,
      xboxAccount: data.user.xboxaccount._attributes.value,
      wiiAccount: data.user.wiiaccount._attributes.value,
      psnAccount: data.user.psnaccount._attributes.value,
      battlenetAccount: data.user.battlenetaccount._attributes.value,
      steamAccount: data.user.steamaccount._attributes.value,
      tradeRating: data.user.traderating._attributes.value,
      buddies: data.user.buddies && {
        total: data.user.buddies._attributes.total,
        page: data.user.buddies._attributes.page,
        buddy: enforceArray(data.user.buddies.buddy).map((data2) => ({
          id: data2._attributes.id,
          name: data2._attributes.name
        }))
      },
      guilds: data.user.guilds && {
        total: data.user.guilds._attributes.total,
        page: data.user.guilds._attributes.page,
        guild: enforceArray(data.user.guilds.guild).map((data2) => ({
          id: data2._attributes.id,
          name: data2._attributes.name
        }))
      },
      hot: data.user.hot && {
        domain: data.user.hot._attributes.domain,
        item: enforceArray(data.user.hot.item).map((data2) => ({
          rank: data2._attributes.rank,
          type: data2._attributes.type,
          id: data2._attributes.id,
          name: data2._attributes.name
        }))
      },
      top: data.user.top && {
        domain: data.user.top._attributes.domain,
        item: enforceArray(data.user.top.item).map((data2) => ({
          rank: data2._attributes.rank,
          type: data2._attributes.type,
          id: data2._attributes.id,
          name: data2._attributes.name
        }))
      }
    }
  };
};
var user = (params) => __async(void 0, null, function* () {
  try {
    const { data } = yield axios.get(endpoint4, {
      params
    });
    return transformData10(data);
  } catch (error) {
    return null;
  }
});

// src/routes/plays/index.ts
var plays_exports = {};
__export(plays_exports, {
  id: () => id,
  username: () => username
});

// src/routes/plays/username.ts
var transformData11 = (data) => {
  if ("div" in data) {
    return null;
  }
  return {
    attributes: {
      termsofuse: data.plays._attributes.termsofuse,
      username: data.plays._attributes.username,
      userid: data.plays._attributes.userid,
      total: data.plays._attributes.total,
      page: data.plays._attributes.page
    },
    plays: enforceArray(data.plays.play).map((play) => ({
      id: play._attributes.id,
      date: play._attributes.date,
      quantity: play._attributes.quantity,
      length: play._attributes.length,
      incomplete: play._attributes.incomplete,
      nowinstats: play._attributes.nowinstats,
      location: play._attributes.location,
      item: {
        name: play.item._attributes.name,
        objecttype: play.item._attributes.objecttype,
        objectid: play.item._attributes.objectid,
        subtypes: enforceArray(play.item.subtypes.subtype).map(
          (subtype) => subtype._attributes.value
        )
      }
    }))
  };
};
var username = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get(
    "/plays",
    {
      params
    }
  );
  return transformData11(data);
});

// src/routes/plays/id.ts
var transformData12 = (data) => {
  const { play, _attributes } = data.plays;
  return {
    attributes: {
      termsofuse: _attributes.termsofuse,
      total: _attributes.total,
      page: _attributes.page
    },
    plays: enforceArray(play).map((play2) => {
      var _a;
      return {
        id: play2._attributes.id,
        date: play2._attributes.date,
        quantity: play2._attributes.quantity,
        length: play2._attributes.length,
        incomplete: play2._attributes.incomplete,
        nowInStats: play2._attributes.nowinstats,
        location: play2._attributes.location,
        item: {
          name: play2.item._attributes.name,
          objectType: play2.item._attributes.objecttype,
          objectId: play2.item._attributes.objectid,
          subtypes: enforceArray(play2.item.subtypes.subtype).map(
            (subtype) => subtype._attributes.value
          )
        },
        players: ((_a = play2.players) == null ? void 0 : _a.player) && enforceArray(play2.players.player).map((player) => ({
          username: player._attributes.username,
          userid: player._attributes.userid,
          name: player._attributes.name,
          startPosition: player._attributes.startposition,
          color: player._attributes.color,
          score: player._attributes.score,
          new: player._attributes.new,
          rating: player._attributes.rating,
          win: player._attributes.win
        }))
      };
    })
  };
};
var id = (params) => __async(void 0, null, function* () {
  const { data } = yield axios.get("/plays", { params });
  return transformData12(data);
});

// src/routes/types/contentTypes.ts
var contentTypes_exports = {};

// src/routes/types/params.ts
var params_exports = {};

// src/routes/types/payloads.ts
var payloads_exports = {};

// src/index.ts
var bgg = {
  collection,
  family,
  forum,
  forumList,
  guild,
  hot,
  search,
  thing,
  thread,
  user,
  plays: __spreadValues({}, plays_exports)
};
var src_default = bgg;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ContentTypes,
  ParamTypes,
  PayloadTypes,
  bgg
});
//# sourceMappingURL=index.js.map