@sonatel-os/strapi-plugin-tcg 0.0.0-stage → 0.3.0

package/dist/_chunks/api-BgR-fpDp.mjs

@@ -0,0 +1,1012 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Flex, Typography, Button, Badge, EmptyStateLayout } from "@strapi/design-system";
+import { Lightbulb, ChevronDown, ChevronUp, CheckCircle, ArrowRight } from "@strapi/icons";
+import { EmptyDocuments } from "@strapi/icons/symbols";
+import { useNavigate } from "react-router-dom";
+import { styled, css, keyframes } from "styled-components";
+import { adminApi } from "@strapi/strapi/admin";
+import { P as PLUGIN_ID } from "./index-ClDgxnnH.mjs";
+const fmtDateTime = (value, locale) => {
+  if (!value) return "—";
+  try {
+    return new Intl.DateTimeFormat(locale ?? void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    }).format(new Date(value));
+  } catch {
+    return String(value);
+  }
+};
+const fmtDate = (value, locale) => {
+  if (!value) return "—";
+  try {
+    return new Intl.DateTimeFormat(locale ?? void 0, { dateStyle: "medium" }).format(
+      new Date(value)
+    );
+  } catch {
+    return String(value);
+  }
+};
+const fmtNumber = (value, locale) => new Intl.NumberFormat(locale ?? void 0).format(Number(value ?? 0));
+const timeAgo = (value) => {
+  if (!value) return "—";
+  const diff = Date.now() - new Date(value).getTime();
+  const s = Math.round(diff / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m} min`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h} h`;
+  return `${Math.round(h / 24)} j`;
+};
+const rarityOf = (season, key) => (season?.rarities ?? []).find((r) => r.key === key) ?? { key, label: key, color: "#8E8EA9" };
+const errorMessage = (err) => err?.data?.error?.message ?? err?.response?.data?.error?.message ?? err?.error?.message ?? err?.message ?? "Une erreur est survenue.";
+const SPRING = "cubic-bezier(0.32, 0.72, 0, 1)";
+const rise = keyframes`
+  from { opacity: 0; transform: translateY(14px); filter: blur(6px); }
+  to   { opacity: 1; transform: translateY(0);    filter: blur(0); }
+`;
+const reveal = css`
+  animation: ${rise} 720ms ${SPRING} both;
+  animation-delay: calc(var(--i, 0) * 70ms);
+  @media (prefers-reduced-motion: reduce) {
+    animation: none;
+  }
+`;
+const Shell = styled.div`
+  ${reveal};
+  width: 100%;
+  height: 100%;
+  background: ${({ theme }) => theme.colors.neutral150};
+  border: 1px solid ${({ theme }) => theme.colors.neutral150};
+  border-radius: 2rem;
+  padding: 0.5rem;
+  box-shadow:
+    0 1px 2px rgba(33, 33, 52, 0.04),
+    0 18px 40px -24px rgba(33, 33, 52, 0.22);
+  transition:
+    transform 480ms ${SPRING},
+    box-shadow 480ms ${SPRING};
+  ${({ $hover }) => $hover && css`
+      cursor: pointer;
+      &:hover {
+        transform: translateY(-3px);
+        box-shadow:
+          0 1px 2px rgba(33, 33, 52, 0.04),
+          0 28px 56px -24px rgba(33, 33, 52, 0.28);
+      }
+      &:active {
+        transform: translateY(-1px) scale(0.995);
+      }
+    `}
+`;
+const Core = styled(Box)`
+  position: relative;
+  background: ${({ theme }) => theme.colors.neutral0};
+  border-radius: calc(2rem - 0.5rem);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9);
+  height: 100%;
+  ${({ $accent }) => $accent && css`
+      overflow: hidden;
+      &::before {
+        content: '';
+        position: absolute;
+        top: -60px;
+        right: -60px;
+        width: 180px;
+        height: 180px;
+        border-radius: 50%;
+        background: radial-gradient(circle, ${$accent}33 0%, ${$accent}00 70%);
+        pointer-events: none;
+      }
+    `}
+`;
+const Card = ({ style, onClick, className, accent, hover, index, children, ...rest }) => /* @__PURE__ */ jsx(
+  Shell,
+  {
+    style: { ...index != null ? { "--i": index } : {}, ...style },
+    onClick,
+    className,
+    $hover: Boolean(hover || onClick),
+    children: /* @__PURE__ */ jsx(Core, { $accent: accent, ...rest, children })
+  }
+);
+const Eyebrow = styled(Typography).attrs({ variant: "sigma", tag: "p" })`
+  letter-spacing: 0.18em;
+  text-transform: uppercase;
+  font-size: 1rem;
+  color: ${({ theme }) => theme.colors.neutral500};
+`;
+const Section = ({ title, eyebrow, help, aside, children, index, accent, ...rest }) => /* @__PURE__ */ jsxs(Card, { padding: 6, index, accent, ...rest, children: [
+  title || aside ? /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      justifyContent: "space-between",
+      alignItems: "flex-start",
+      paddingBottom: help ? 2 : 5,
+      gap: 4,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          eyebrow ? /* @__PURE__ */ jsx(Eyebrow, { paddingBottom: 1, children: eyebrow }) : null,
+          typeof title === "string" ? /* @__PURE__ */ jsx(Typography, { variant: "delta", tag: "h2", fontWeight: "bold", children: title }) : title
+        ] }),
+        aside
+      ]
+    }
+  ) : null,
+  help ? /* @__PURE__ */ jsx(
+    Typography,
+    {
+      variant: "pi",
+      textColor: "neutral600",
+      tag: "p",
+      paddingBottom: 5,
+      style: { maxWidth: "72ch" },
+      children: help
+    }
+  ) : null,
+  children
+] });
+const Big = styled(Typography)`
+  font-size: 3.2rem;
+  line-height: 1;
+  font-weight: 700;
+  letter-spacing: -0.035em;
+  font-variant-numeric: tabular-nums;
+`;
+const StatTile = ({ label, value, hint, accent, icon, index, children }) => /* @__PURE__ */ jsxs(Card, { padding: 5, accent, index, children: [
+  /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", children: [
+    /* @__PURE__ */ jsx(Eyebrow, { children: label }),
+    icon ? /* @__PURE__ */ jsx(
+      Box,
+      {
+        style: {
+          color: accent ?? "#8E8EA9",
+          display: "inline-flex",
+          width: 32,
+          height: 32,
+          borderRadius: 10,
+          alignItems: "center",
+          justifyContent: "center",
+          background: `${accent ?? "#8E8EA9"}14`
+        },
+        children: icon
+      }
+    ) : null
+  ] }),
+  /* @__PURE__ */ jsx(Box, { paddingTop: 4, paddingBottom: 1, children: /* @__PURE__ */ jsx(Big, { tag: "p", children: value }) }),
+  hint ? /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral500", tag: "p", children: hint }) : null,
+  children
+] });
+const PillBtn = styled.button`
+  display: inline-flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.4rem 0.4rem 0.4rem 1.6rem;
+  border-radius: 999px;
+  border: 0;
+  cursor: pointer;
+  font: inherit;
+  font-size: 1.4rem;
+  font-weight: 600;
+  color: ${({ theme, $tone }) => $tone === "light" ? theme.colors.neutral800 : theme.colors.neutral0};
+  background: ${({ theme, $tone }) => $tone === "light" ? theme.colors.neutral0 : theme.colors.neutral800};
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.12),
+    0 10px 24px -12px rgba(33, 33, 52, 0.45);
+  transition:
+    transform 420ms ${SPRING},
+    box-shadow 420ms ${SPRING};
+  span.disc {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 3rem;
+    height: 3rem;
+    border-radius: 50%;
+    background: ${({ $tone }) => $tone === "light" ? "rgba(33,33,52,0.06)" : "rgba(255,255,255,0.14)"};
+    transition: transform 420ms ${SPRING};
+    svg {
+      width: 1.4rem;
+      height: 1.4rem;
+    }
+  }
+  &:hover {
+    transform: translateY(-1px);
+    box-shadow:
+      inset 0 1px 0 rgba(255, 255, 255, 0.12),
+      0 16px 30px -12px rgba(33, 33, 52, 0.5);
+  }
+  &:hover span.disc {
+    transform: translate(2px, -1px) scale(1.06);
+  }
+  &:active {
+    transform: scale(0.98);
+  }
+`;
+const Pill = ({ children, onClick, tone = "dark", icon = /* @__PURE__ */ jsx(ArrowRight, {}) }) => /* @__PURE__ */ jsxs(PillBtn, { type: "button", onClick, $tone: tone, children: [
+  children,
+  /* @__PURE__ */ jsx("span", { className: "disc", "aria-hidden": true, children: icon })
+] });
+const Dot = styled.span`
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: ${({ $color }) => $color};
+  box-shadow:
+    0 0 0 2px ${({ theme }) => theme.colors.neutral0},
+    0 0 0 3px ${({ $color }) => $color}33;
+`;
+const RarityBadge = ({ season, rarity }) => {
+  const meta = rarityOf(season, rarity);
+  return /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", style: { display: "inline-flex" }, children: [
+    /* @__PURE__ */ jsx(Dot, { $color: meta.color }),
+    /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "semiBold", children: meta.label })
+  ] });
+};
+const STATUS_LABEL = {
+  active: "Active",
+  pending: "Pending",
+  fulfilled: "Handed over",
+  accepted: "Accepted",
+  draft: "Draft",
+  archived: "Archived",
+  cancelled: "Cancelled",
+  rejected: "Rejected",
+  expired: "Expired",
+  open: "Open",
+  closed: "Closed",
+  inactive: "Inactive",
+  live: "Live",
+  scheduled: "Scheduled"
+};
+const StatusBadge = ({ status, label }) => {
+  const map = {
+    active: "success",
+    live: "success",
+    open: "success",
+    pending: "warning",
+    scheduled: "warning",
+    fulfilled: "success",
+    accepted: "success",
+    draft: "secondary",
+    archived: "neutral",
+    inactive: "neutral",
+    closed: "neutral",
+    cancelled: "danger",
+    rejected: "danger",
+    expired: "neutral"
+  };
+  const v = map[status] ?? "neutral";
+  return /* @__PURE__ */ jsx(Badge, { backgroundColor: `${v}100`, textColor: `${v}700`, size: "S", children: label ?? STATUS_LABEL[status] ?? status });
+};
+const Sparkline = ({ points = [], color = "currentColor", height = 36 }) => {
+  const w = 160;
+  const max = Math.max(1, ...points);
+  const step = points.length > 1 ? w / (points.length - 1) : w;
+  const d = points.map(
+    (p, i) => `${i === 0 ? "M" : "L"}${(i * step).toFixed(1)},${(height - p / max * (height - 4) - 2).toFixed(1)}`
+  ).join(" ");
+  const id = `sp-${color.replace(/[^a-z0-9]/gi, "")}`;
+  return /* @__PURE__ */ jsxs("svg", { width: w, height, viewBox: `0 0 ${w} ${height}`, role: "img", "aria-label": "trend", children: [
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsxs("linearGradient", { id, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: color, stopOpacity: "0.25" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: color, stopOpacity: "0" })
+    ] }) }),
+    d ? /* @__PURE__ */ jsx("path", { d: `${d} L${w},${height} L0,${height} Z`, fill: `url(#${id})` }) : null,
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d,
+        fill: "none",
+        stroke: color,
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    )
+  ] });
+};
+const Empty = ({ title, content, action }) => /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsx(
+  EmptyStateLayout,
+  {
+    icon: /* @__PURE__ */ jsx(EmptyDocuments, { width: "10rem" }),
+    content: title ? `${title} ${content ?? ""}`.trim() : content,
+    action,
+    shadow: "none"
+  }
+) });
+const Mono = styled(Typography)`
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  letter-spacing: 0.04em;
+  font-variant-numeric: tabular-nums;
+`;
+const Bar = ({ value, max, color }) => {
+  const w = max ? Math.min(100, Math.round(value / max * 100)) : 0;
+  return /* @__PURE__ */ jsx(Box, { background: "neutral150", hasRadius: true, style: { height: 8, overflow: "hidden" }, children: /* @__PURE__ */ jsx(
+    Box,
+    {
+      style: {
+        width: `${w}%`,
+        height: "100%",
+        borderRadius: 999,
+        background: color ? `linear-gradient(90deg, ${color}, ${color}cc)` : "linear-gradient(90deg, #FF7900, #FACC15)",
+        transition: `width 700ms ${SPRING}`
+      }
+    }
+  ) });
+};
+const introKey = (k) => `tcg.intro.${k}`;
+const recallCollapsed = (k) => {
+  try {
+    return window.localStorage.getItem(introKey(k)) === "1";
+  } catch {
+    return false;
+  }
+};
+const rememberCollapsed = (k, v) => {
+  try {
+    if (v) window.localStorage.setItem(introKey(k), "1");
+    else window.localStorage.removeItem(introKey(k));
+  } catch {
+  }
+};
+const IntroShell = styled.div`
+  ${reveal};
+  position: relative;
+  overflow: hidden;
+  border-radius: 2rem;
+  padding: 0.5rem;
+  background: linear-gradient(135deg, #eef0ff 0%, #f6f6f9 55%, #fff4ea 100%);
+  box-shadow: 0 18px 40px -28px rgba(73, 69, 255, 0.35);
+`;
+const IntroCore = styled.div`
+  position: relative;
+  border-radius: calc(2rem - 0.5rem);
+  background: rgba(255, 255, 255, 0.72);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.9);
+  padding: ${({ $collapsed }) => $collapsed ? "1rem 1.6rem" : "2.4rem 2.8rem"};
+  transition: padding 420ms ${SPRING};
+`;
+const StepNo = styled.span`
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2.4rem;
+  height: 2.4rem;
+  border-radius: 50%;
+  flex-shrink: 0;
+  font-size: 1.1rem;
+  font-weight: 700;
+  background: ${({ theme }) => theme.colors.neutral800};
+  color: ${({ theme }) => theme.colors.neutral0};
+`;
+const Intro = ({ id, title, body = [], steps = [], links = [] }) => {
+  const navigate = useNavigate();
+  const [collapsed, setCollapsed] = useState(() => recallCollapsed(id));
+  const toggle = () => {
+    rememberCollapsed(id, !collapsed);
+    setCollapsed(!collapsed);
+  };
+  return /* @__PURE__ */ jsx(Box, { marginBottom: 7, children: /* @__PURE__ */ jsx(IntroShell, { children: /* @__PURE__ */ jsxs(IntroCore, { $collapsed: collapsed, children: [
+    /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", gap: 4, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "center", children: [
+        /* @__PURE__ */ jsx(Box, { style: { color: "#4945FF", display: "flex" }, children: /* @__PURE__ */ jsx(Lightbulb, { width: "1.8rem", height: "1.8rem" }) }),
+        /* @__PURE__ */ jsxs(Box, { children: [
+          collapsed ? null : /* @__PURE__ */ jsx(Eyebrow, { children: "Guide" }),
+          /* @__PURE__ */ jsx(Typography, { variant: collapsed ? "omega" : "beta", fontWeight: "bold", tag: "h2", children: title })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "S",
+          onClick: toggle,
+          endIcon: collapsed ? /* @__PURE__ */ jsx(ChevronDown, {}) : /* @__PURE__ */ jsx(ChevronUp, {}),
+          children: collapsed ? "Show the guide" : "Hide"
+        }
+      )
+    ] }),
+    collapsed ? null : /* @__PURE__ */ jsxs(Flex, { gap: 10, alignItems: "flex-start", paddingTop: 4, wrap: "wrap", children: [
+      /* @__PURE__ */ jsxs(Box, { style: { flex: "2 1 360px", minWidth: 0 }, children: [
+        body.map((p, i) => /* @__PURE__ */ jsx(
+          Typography,
+          {
+            tag: "p",
+            textColor: "neutral700",
+            paddingBottom: 3,
+            style: { maxWidth: "68ch", lineHeight: 1.6 },
+            children: p
+          },
+          i
+        )),
+        links.length ? /* @__PURE__ */ jsx(Flex, { gap: 3, paddingTop: 2, wrap: "wrap", children: links.map((l) => /* @__PURE__ */ jsx(Pill, { tone: "light", onClick: () => navigate(l.to), children: l.label }, l.to)) }) : null
+      ] }),
+      steps.length ? /* @__PURE__ */ jsxs(Box, { style: { flex: "1 1 260px", minWidth: 0 }, children: [
+        /* @__PURE__ */ jsx(Eyebrow, { paddingBottom: 3, children: "How to" }),
+        /* @__PURE__ */ jsx(Flex, { direction: "column", alignItems: "stretch", gap: 3, children: steps.map((s, i) => {
+          const label = typeof s === "string" ? s : s.label;
+          const to = typeof s === "string" ? null : s.to;
+          return /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "center", children: [
+            /* @__PURE__ */ jsx(StepNo, { children: i + 1 }),
+            to ? /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "S",
+                onClick: () => navigate(to),
+                style: { padding: 0 },
+                children: label
+              }
+            ) : /* @__PURE__ */ jsx(Typography, { variant: "omega", children: label })
+          ] }, i);
+        }) })
+      ] }) : null
+    ] })
+  ] }) }) });
+};
+const StepRow = styled(Flex)`
+  border-top: 1px solid ${({ theme }) => theme.colors.neutral150};
+  &:first-child {
+    border-top: none;
+  }
+`;
+const Circle = styled.span`
+  display: inline-flex;
+  width: 2.4rem;
+  height: 2.4rem;
+  border-radius: 50%;
+  border: 2px solid ${({ theme }) => theme.colors.neutral300};
+  flex-shrink: 0;
+`;
+const SetupSteps = ({ steps }) => {
+  const navigate = useNavigate();
+  return /* @__PURE__ */ jsx(Flex, { direction: "column", alignItems: "stretch", children: steps.map((s, i) => /* @__PURE__ */ jsxs(StepRow, { gap: 4, alignItems: "center", paddingTop: 4, paddingBottom: 4, children: [
+    s.done ? /* @__PURE__ */ jsx(Box, { style: { color: "#328048", display: "flex" }, children: /* @__PURE__ */ jsx(CheckCircle, { width: "2.4rem", height: "2.4rem" }) }) : /* @__PURE__ */ jsx(Circle, {}),
+    /* @__PURE__ */ jsxs(Box, { style: { flex: 1, minWidth: 0 }, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", children: [
+        /* @__PURE__ */ jsx(Typography, { fontWeight: "semiBold", textColor: s.done ? "neutral600" : "neutral800", children: s.title }),
+        s.count ? /* @__PURE__ */ jsx(Badge, { size: "S", children: s.count }) : null
+      ] }),
+      /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", tag: "p", children: s.help })
+    ] }),
+    s.to ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "S",
+        variant: s.done ? "tertiary" : "secondary",
+        onClick: () => navigate(s.to),
+        children: s.done ? "Open" : s.cta ?? "Do it"
+      }
+    ) : null
+  ] }, i)) });
+};
+const BASE = `/${PLUGIN_ID}`;
+const TAG = Object.freeze({
+  DASH: "TcgDashboard",
+  SEASON: "TcgSeason",
+  CARD: "TcgCard",
+  PACK: "TcgPack",
+  PLAYER: "TcgPlayer",
+  REDEMPTION: "TcgRedemption",
+  DROP: "TcgDrop",
+  BOOST: "TcgBoost",
+  REWARD: "TcgReward",
+  SET: "TcgSet",
+  BADGE: "TcgBadge"
+});
+const unwrap = (res) => res && typeof res === "object" && "data" in res ? res.data : res;
+const qs = (params = {}) => {
+  const clean = Object.fromEntries(
+    Object.entries(params).filter(([, v]) => v !== void 0 && v !== null && v !== "")
+  );
+  const s = new URLSearchParams(clean).toString();
+  return s ? `?${s}` : "";
+};
+const enc = encodeURIComponent;
+const api = adminApi.enhanceEndpoints({ addTagTypes: Object.values(TAG) }).injectEndpoints({
+  endpoints: (b) => ({
+    // dashboard
+    getDashboard: b.query({
+      query: (season) => `${BASE}/dashboard${qs({ season })}`,
+      transformResponse: unwrap,
+      providesTags: [TAG.DASH]
+    }),
+    getLeaderboard: b.query({
+      query: ({ season, limit }) => `${BASE}/seasons/${enc(season)}/leaderboard${qs({ limit })}`,
+      transformResponse: unwrap,
+      providesTags: [TAG.DASH]
+    }),
+    getPulls: b.query({
+      query: ({ season, ...p }) => `${BASE}/seasons/${enc(season)}/pulls${qs(p)}`,
+      providesTags: [TAG.DASH]
+    }),
+    // seasons
+    getSeasons: b.query({
+      query: () => `${BASE}/seasons`,
+      transformResponse: unwrap,
+      providesTags: [TAG.SEASON]
+    }),
+    getSeasonDefaults: b.query({
+      query: () => `${BASE}/seasons/defaults`,
+      transformResponse: unwrap
+    }),
+    getSeason: b.query({
+      query: (ref) => `${BASE}/seasons/${enc(ref)}`,
+      transformResponse: unwrap,
+      providesTags: (_r, _e, ref) => [{ type: TAG.SEASON, id: ref }, TAG.SEASON]
+    }),
+    createSeason: b.mutation({
+      query: (data) => ({ url: `${BASE}/seasons`, method: "POST", data: { data } }),
+      invalidatesTags: [TAG.SEASON, TAG.DASH]
+    }),
+    updateSeason: b.mutation({
+      query: ({ ref, data }) => ({
+        url: `${BASE}/seasons/${enc(ref)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.SEASON, TAG.DASH]
+    }),
+    deleteSeason: b.mutation({
+      query: (ref) => ({ url: `${BASE}/seasons/${enc(ref)}`, method: "DELETE" }),
+      invalidatesTags: [TAG.SEASON, TAG.DASH]
+    }),
+    // cards
+    getCards: b.query({
+      query: ({ season, ...p }) => `${BASE}/seasons/${enc(season)}/cards${qs(p)}`,
+      providesTags: [TAG.CARD]
+    }),
+    createCard: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/cards`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.CARD, TAG.SEASON, TAG.DASH]
+    }),
+    updateCard: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/cards/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.CARD, TAG.PACK]
+    }),
+    deleteCard: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/cards/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.CARD, TAG.PACK, TAG.SEASON]
+    }),
+    // packs
+    getPacks: b.query({
+      query: (season) => `${BASE}/seasons/${enc(season)}/packs`,
+      transformResponse: unwrap,
+      providesTags: [TAG.PACK]
+    }),
+    getPack: b.query({
+      query: ({ season, id }) => `${BASE}/seasons/${enc(season)}/packs/${enc(id)}`,
+      transformResponse: unwrap,
+      providesTags: (_r, _e, { id }) => [{ type: TAG.PACK, id }, TAG.PACK]
+    }),
+    createPack: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.PACK, TAG.SEASON, TAG.DASH]
+    }),
+    updatePack: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.PACK]
+    }),
+    deletePack: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.PACK, TAG.SEASON]
+    }),
+    setPackCards: b.mutation({
+      query: ({ season, id, cards }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/cards`,
+        method: "PUT",
+        data: { data: { cards } }
+      }),
+      invalidatesTags: [TAG.PACK]
+    }),
+    packQR: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/qr`,
+        method: "POST",
+        data: {}
+      }),
+      transformResponse: unwrap
+    }),
+    rotatePackSecret: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/rotate-secret`,
+        method: "POST",
+        data: {}
+      })
+    }),
+    simulatePack: b.query({
+      query: ({ season, id, n, drop }) => `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/simulate${qs({ n, drop })}`,
+      transformResponse: unwrap
+    }),
+    // drops
+    getDrops: b.query({
+      query: ({ season, id }) => `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops`,
+      transformResponse: unwrap,
+      providesTags: [TAG.DROP]
+    }),
+    getDrop: b.query({
+      query: ({ season, id, dropId }) => `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}`,
+      transformResponse: unwrap,
+      providesTags: (_r, _e, { dropId }) => [{ type: TAG.DROP, id: dropId }, TAG.DROP]
+    }),
+    createDrop: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.DROP, TAG.PACK]
+    }),
+    updateDrop: b.mutation({
+      query: ({ season, id, dropId, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.DROP, TAG.PACK]
+    }),
+    deleteDrop: b.mutation({
+      query: ({ season, id, dropId }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.DROP, TAG.PACK]
+    }),
+    setDropCards: b.mutation({
+      query: ({ season, id, dropId, cards }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}/cards`,
+        method: "PUT",
+        data: { data: { cards } }
+      }),
+      invalidatesTags: [TAG.DROP, TAG.CARD]
+    }),
+    dropQR: b.mutation({
+      query: ({ season, id, dropId }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}/qr`,
+        method: "POST",
+        data: {}
+      }),
+      transformResponse: unwrap
+    }),
+    rotateDropSecret: b.mutation({
+      query: ({ season, id, dropId }) => ({
+        url: `${BASE}/seasons/${enc(season)}/packs/${enc(id)}/drops/${enc(dropId)}/rotate-secret`,
+        method: "POST",
+        data: {}
+      })
+    }),
+    // boosts
+    getBoosts: b.query({
+      query: (season) => `${BASE}/seasons/${enc(season)}/boosts`,
+      transformResponse: unwrap,
+      providesTags: [TAG.BOOST]
+    }),
+    createBoost: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/boosts`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.BOOST, TAG.DASH]
+    }),
+    updateBoost: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/boosts/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.BOOST, TAG.DASH]
+    }),
+    deleteBoost: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/boosts/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.BOOST, TAG.DASH]
+    }),
+    // rewards
+    getRewards: b.query({
+      query: (season) => `${BASE}/seasons/${enc(season)}/rewards`,
+      transformResponse: unwrap,
+      providesTags: [TAG.REWARD]
+    }),
+    createReward: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/rewards`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.REWARD, TAG.DASH]
+    }),
+    updateReward: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/rewards/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.REWARD, TAG.DASH]
+    }),
+    deleteReward: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/rewards/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.REWARD]
+    }),
+    // sets & badges
+    getSets: b.query({
+      query: (season) => `${BASE}/seasons/${enc(season)}/sets`,
+      transformResponse: unwrap,
+      providesTags: [TAG.SET]
+    }),
+    createSet: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/sets`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.SET]
+    }),
+    updateSet: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/sets/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.SET]
+    }),
+    deleteSet: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/sets/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.SET]
+    }),
+    getBadges: b.query({
+      query: (season) => `${BASE}/seasons/${enc(season)}/badges`,
+      transformResponse: unwrap,
+      providesTags: [TAG.BADGE]
+    }),
+    createBadge: b.mutation({
+      query: ({ season, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/badges`,
+        method: "POST",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.BADGE]
+    }),
+    updateBadge: b.mutation({
+      query: ({ season, id, data }) => ({
+        url: `${BASE}/seasons/${enc(season)}/badges/${enc(id)}`,
+        method: "PUT",
+        data: { data }
+      }),
+      invalidatesTags: [TAG.BADGE]
+    }),
+    deleteBadge: b.mutation({
+      query: ({ season, id }) => ({
+        url: `${BASE}/seasons/${enc(season)}/badges/${enc(id)}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: [TAG.BADGE]
+    }),
+    seedBadges: b.mutation({
+      query: (season) => ({
+        url: `${BASE}/seasons/${enc(season)}/badges/seed`,
+        method: "POST",
+        data: {}
+      }),
+      invalidatesTags: [TAG.BADGE]
+    }),
+    // players
+    getPlayers: b.query({ query: (p) => `${BASE}/players${qs(p)}`, providesTags: [TAG.PLAYER] }),
+    getPlayer: b.query({
+      query: ({ id, season }) => `${BASE}/players/${enc(id)}${qs({ season })}`,
+      transformResponse: unwrap,
+      providesTags: (_r, _e, { id }) => [{ type: TAG.PLAYER, id }]
+    }),
+    setPlayerActive: b.mutation({
+      query: ({ id, isActive }) => ({
+        url: `${BASE}/players/${enc(id)}/active`,
+        method: "PUT",
+        data: { data: { isActive } }
+      }),
+      invalidatesTags: [TAG.PLAYER]
+    }),
+    grantCard: b.mutation({
+      query: ({ id, cardId }) => ({
+        url: `${BASE}/players/${enc(id)}/grant`,
+        method: "POST",
+        data: { data: { cardId } }
+      }),
+      invalidatesTags: [TAG.PLAYER, TAG.DASH]
+    }),
+    // redemptions
+    getRedemptions: b.query({
+      query: (p) => `${BASE}/redemptions${qs(p)}`,
+      providesTags: [TAG.REDEMPTION]
+    }),
+    getRedemption: b.query({
+      query: (code) => `${BASE}/redemptions/${enc(code)}`,
+      transformResponse: unwrap,
+      providesTags: (_r, _e, code) => [{ type: TAG.REDEMPTION, id: code }]
+    }),
+    fulfillRedemption: b.mutation({
+      query: ({ code, note }) => ({
+        url: `${BASE}/redemptions/${enc(code)}/fulfill`,
+        method: "POST",
+        data: { data: { note } }
+      }),
+      invalidatesTags: [TAG.REDEMPTION, TAG.DASH]
+    }),
+    cancelRedemption: b.mutation({
+      query: ({ code, note }) => ({
+        url: `${BASE}/redemptions/${enc(code)}/cancel`,
+        method: "POST",
+        data: { data: { note } }
+      }),
+      invalidatesTags: [TAG.REDEMPTION, TAG.DASH, TAG.PLAYER]
+    }),
+    // settings
+    getSettings: b.query({ query: () => `${BASE}/settings`, transformResponse: unwrap })
+  })
+});
+const {
+  useGetDashboardQuery,
+  useGetLeaderboardQuery,
+  useGetPullsQuery,
+  useGetSeasonsQuery,
+  useGetSeasonDefaultsQuery,
+  useGetSeasonQuery,
+  useCreateSeasonMutation,
+  useUpdateSeasonMutation,
+  useDeleteSeasonMutation,
+  useGetCardsQuery,
+  useCreateCardMutation,
+  useUpdateCardMutation,
+  useDeleteCardMutation,
+  useGetPacksQuery,
+  useGetPackQuery,
+  useCreatePackMutation,
+  useUpdatePackMutation,
+  useDeletePackMutation,
+  useSetPackCardsMutation,
+  usePackQRMutation,
+  useRotatePackSecretMutation,
+  useLazySimulatePackQuery,
+  useGetDropsQuery,
+  useGetDropQuery,
+  useCreateDropMutation,
+  useUpdateDropMutation,
+  useDeleteDropMutation,
+  useSetDropCardsMutation,
+  useDropQRMutation,
+  useRotateDropSecretMutation,
+  useGetBoostsQuery,
+  useCreateBoostMutation,
+  useUpdateBoostMutation,
+  useDeleteBoostMutation,
+  useGetRewardsQuery,
+  useCreateRewardMutation,
+  useUpdateRewardMutation,
+  useDeleteRewardMutation,
+  useGetSetsQuery,
+  useCreateSetMutation,
+  useUpdateSetMutation,
+  useDeleteSetMutation,
+  useGetBadgesQuery,
+  useCreateBadgeMutation,
+  useUpdateBadgeMutation,
+  useDeleteBadgeMutation,
+  useSeedBadgesMutation,
+  useGetPlayersQuery,
+  useGetPlayerQuery,
+  useSetPlayerActiveMutation,
+  useGrantCardMutation,
+  useGetRedemptionsQuery,
+  useLazyGetRedemptionQuery,
+  useFulfillRedemptionMutation,
+  useCancelRedemptionMutation,
+  useGetSettingsQuery
+} = api;
+export {
+  useUpdateDropMutation as $,
+  useGetPacksQuery as A,
+  Bar as B,
+  Card as C,
+  useCreatePackMutation as D,
+  Eyebrow as E,
+  useGetPackQuery as F,
+  useUpdatePackMutation as G,
+  useSetPackCardsMutation as H,
+  Intro as I,
+  useDeletePackMutation as J,
+  useCreateDropMutation as K,
+  useLazySimulatePackQuery as L,
+  useGetPlayersQuery as M,
+  fmtDateTime as N,
+  useGetPlayerQuery as O,
+  Pill as P,
+  useSetPlayerActiveMutation as Q,
+  RarityBadge as R,
+  SPRING as S,
+  useGrantCardMutation as T,
+  useLazyGetRedemptionQuery as U,
+  useFulfillRedemptionMutation as V,
+  useCancelRedemptionMutation as W,
+  useGetRedemptionsQuery as X,
+  Mono as Y,
+  useGetPullsQuery as Z,
+  useGetDropQuery as _,
+  useGetDashboardQuery as a,
+  useSetDropCardsMutation as a0,
+  useDeleteDropMutation as a1,
+  useRotateDropSecretMutation as a2,
+  useDropQRMutation as a3,
+  useGetBoostsQuery as a4,
+  useCreateBoostMutation as a5,
+  useUpdateBoostMutation as a6,
+  useDeleteBoostMutation as a7,
+  useCreateRewardMutation as a8,
+  useUpdateRewardMutation as a9,
+  useDeleteRewardMutation as aa,
+  useCreateSetMutation as ab,
+  useUpdateSetMutation as ac,
+  useDeleteSetMutation as ad,
+  useCreateBadgeMutation as ae,
+  useUpdateBadgeMutation as af,
+  useDeleteBadgeMutation as ag,
+  useSeedBadgesMutation as ah,
+  useGetSettingsQuery as ai,
+  useGetLeaderboardQuery as b,
+  useGetRewardsQuery as c,
+  useGetSetsQuery as d,
+  useGetBadgesQuery as e,
+  Empty as f,
+  Section as g,
+  SetupSteps as h,
+  StatTile as i,
+  Sparkline as j,
+  fmtNumber as k,
+  StatusBadge as l,
+  fmtDate as m,
+  useGetSeasonDefaultsQuery as n,
+  useGetSeasonQuery as o,
+  useCreateSeasonMutation as p,
+  useUpdateSeasonMutation as q,
+  useDeleteSeasonMutation as r,
+  errorMessage as s,
+  timeAgo as t,
+  useGetSeasonsQuery as u,
+  useGetCardsQuery as v,
+  useCreateCardMutation as w,
+  useUpdateCardMutation as x,
+  useDeleteCardMutation as y,
+  rarityOf as z
+};