@frigear-nu/events 0.0.7 → 0.0.9

package/dist/runtime/app/widgets/UpcomingEventsStat.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/i18n/lang/da.json

@@ -73,6 +73,22 @@
     "loading": "Henter…",
     "members": "Medlemmer",
     "viewEvent": "Se event",
+    "picker": {
+      "soldOut": "Udsolgt",
+      "notStarted": "Salget er ikke startet",
+      "ended": "Salget er slut",
+      "membersOnly": "Kun for medlemmer",
+      "notForMembers": "Ikke for medlemmer",
+      "booked": "Allerede booket",
+      "left": "tilbage",
+      "free": "Gratis",
+      "included": "Inkluderet",
+      "getFree": "Få gratis billet",
+      "buy": "Køb billet",
+      "signIn": "Log ind for at få en billet.",
+      "noTickets": "Der er ingen billetter til dette event."
+    },
+    "backToEvents": "Alle events",
     "hideQr": "Skjul QR-kode",
     "checkedIn": "Tjekket ind",
     "myTickets": "Mine billetter",
@@ -87,6 +103,23 @@
       "tickets": {
         "label": "Billetter",
         "description": "Dine billetter til arrangementer."
+      },
+      "admin": {
+        "label": "Arrangementer",
+        "description": "Administrér arrangementer, billettyper og deltagere."
+      }
+    },
+    "admin": {
+      "tabs": {
+        "details": "Detaljer",
+        "tickets": "Billetter",
+        "attendees": "Deltagere"
+      },
+      "upcoming": {
+        "stat": "Kommende arrangementer",
+        "title": "Kommende arrangementer",
+        "empty": "Ingen kommende arrangementer.",
+        "all": "Alle arrangementer"
       }
     }
   }

package/dist/runtime/i18n/lang/en.json

@@ -69,6 +69,22 @@
     "loading": "Loading…",
     "members": "Members",
     "viewEvent": "View event",
+    "picker": {
+      "soldOut": "Sold out",
+      "notStarted": "Sales not started",
+      "ended": "Sales ended",
+      "membersOnly": "Members only",
+      "notForMembers": "Not for members",
+      "booked": "Already booked",
+      "left": "left",
+      "free": "Free",
+      "included": "Included",
+      "getFree": "Get free ticket",
+      "buy": "Buy ticket",
+      "signIn": "Sign in to get a ticket.",
+      "noTickets": "No tickets are available for this event."
+    },
+    "backToEvents": "All events",
     "hideQr": "Hide QR code",
     "checkedIn": "Checked in",
     "myTickets": "My tickets",
@@ -87,6 +103,23 @@
       "tickets": {
         "label": "Tickets",
         "description": "Your event tickets."
+      },
+      "admin": {
+        "label": "Events",
+        "description": "Manage events, ticket types and attendees."
+      }
+    },
+    "admin": {
+      "tabs": {
+        "details": "Details",
+        "tickets": "Tickets",
+        "attendees": "Attendees"
+      },
+      "upcoming": {
+        "stat": "Upcoming events",
+        "title": "Upcoming events",
+        "empty": "No upcoming events.",
+        "all": "All events"
       }
     }
   }

package/dist/runtime/menus.js

@@ -2,7 +2,7 @@ import { defineMenuItem, defineMenuSource, extendMenuItem } from "@frigear-nu/me
 export default defineMenuSource(() => {
   const config = useRuntimeConfig().public.events;
   if (config?.pages?.tickets) {
-    extendMenuItem("dashboard.account", defineMenuItem({
+    const item = defineMenuItem({
       id: "event-tickets",
       label: "Tickets",
       labelKey: "events.menu.tickets.label",
@@ -11,6 +11,20 @@ export default defineMenuSource(() => {
       icon: "i-lucide-ticket",
       to: config.pages.tickets,
       order: 40
+    });
+    extendMenuItem("account", item);
+    extendMenuItem("dashboard.account", item);
+  }
+  if (config?.pages?.admin) {
+    extendMenuItem("admin.nav", defineMenuItem({
+      id: "events-admin",
+      label: "Events",
+      labelKey: "events.menu.admin.label",
+      description: "Manage events, ticket types and attendees.",
+      descriptionKey: "events.menu.admin.description",
+      icon: "i-lucide-calendar-days",
+      to: config.pages.admin,
+      order: 20
     }));
   }
 });

package/dist/runtime/server/db/schema.sqlite.d.ts

@@ -120,21 +120,21 @@ export declare const events: import("drizzle-orm/sqlite-core").SQLiteTableWithCo
         location: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "location";
             tableName: "events";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Translated;
             driverParam: string;
             notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
         }, {}, {
-            length: undefined;
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
         }>;
         locationUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "locationUrl";
@@ -467,6 +467,25 @@ export declare const eventTicketTypes: import("drizzle-orm/sqlite-core").SQLiteT
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        saleSchedule: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "saleSchedule";
+            tableName: "event_ticket_types";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: import("@frigear-nu/module-kit/schedule").Schedule;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: import("@frigear-nu/module-kit/schedule").Schedule;
+        }>;
         maxPerUser: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "maxPerUser";
             tableName: "event_ticket_types";
@@ -503,6 +522,25 @@ export declare const eventTicketTypes: import("drizzle-orm/sqlite-core").SQLiteT
         }, {}, {
             $type: string[] | "any";
         }>;
+        excludesMembership: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "excludesMembership";
+            tableName: "event_ticket_types";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: string[] | "any";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[] | "any";
+        }>;
         isDefault: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "isDefault";
             tableName: "event_ticket_types";
@@ -1021,6 +1059,25 @@ export declare const eventTickets: import("drizzle-orm/sqlite-core").SQLiteTable
         }, {}, {
             length: undefined;
         }>;
+        locale: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "locale";
+            tableName: "event_tickets";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
         checkedInAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "checkedInAt";
             tableName: "event_tickets";

package/dist/runtime/server/db/schema.sqlite.js

@@ -1,4 +1,4 @@
-import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { sqliteTable, text, integer, index, uniqueIndex, customType } from "drizzle-orm/sqlite-core";
 export const events = sqliteTable("events", {
   /** `evn_` + random id. */
   id: text().primaryKey(),
@@ -8,7 +8,23 @@ export const events = sqliteTable("events", {
   /** Markdown body (per locale). */
   body: text({ mode: "json" }).$type(),
   image: text(),
-  location: text(),
+  // A plain `text` column that also holds a `Translated`: strings are stored as they are (so rows written before
+  // locations could be translated keep working), per-locale maps as json. No schema change, hence no migration.
+  // Kept inline: module-kit lifts each table's columns into the host schema, so helpers declared above would be lost.
+  location: customType({
+    dataType: () => "text",
+    toDriver: (value) => typeof value === "string" ? value : JSON.stringify(value),
+    fromDriver: (value) => {
+      if (value.startsWith("{")) {
+        try {
+          const parsed = JSON.parse(value);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+        } catch {
+        }
+      }
+      return value;
+    }
+  })(),
   locationUrl: text(),
   startsAt: integer({ mode: "timestamp" }).notNull(),
   endsAt: integer({ mode: "timestamp" }),
@@ -37,9 +53,16 @@ export const eventTicketTypes = sqliteTable("event_ticket_types", {
   capacity: integer(),
   saleStartsAt: integer({ mode: "timestamp" }),
   saleEndsAt: integer({ mode: "timestamp" }),
+  /** Optional recurring sale season (`yearly`) or fixed `range`, checked on top of `saleStartsAt`/`saleEndsAt`; null = always. */
+  saleSchedule: text({ mode: "json" }).$type(),
   maxPerUser: integer().notNull().default(1),
   /** `null` = open to everyone, `'any'` = any active subscription, or a list of plan keys. */
   requiresMembership: text({ mode: "json" }).$type(),
+  /**
+   * The opposite: holders of these plans can NOT buy this ticket (`'any'` = any active subscription), so a
+   * member price and a non-member price can be separate ticket types. `null` = nobody is excluded.
+   */
+  excludesMembership: text({ mode: "json" }).$type(),
   isDefault: integer({ mode: "boolean" }).notNull().default(false),
   sortOrder: integer().notNull().default(0),
   createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
@@ -89,6 +112,8 @@ export const eventTickets = sqliteTable("event_tickets", {
   currency: text().notNull(),
   /** Unguessable value shown as a QR code and scanned at check-in. */
   code: text().notNull().unique(),
+  /** Language the buyer was browsing in; used for mails and payment texts after the purchase. */
+  locale: text(),
   checkedInAt: integer({ mode: "timestamp" }),
   checkedInBy: integer(),
   createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),

package/dist/runtime/server/mcp/money.d.ts

@@ -0,0 +1,24 @@
+type Priced = {
+    price?: number | null;
+};
+type TypeLike = Priced & {
+    currency?: string | null;
+    addonGroups?: Array<{
+        addons?: Priced[];
+    }>;
+};
+/** Output: a ticket type (DTO or row) with its price and add-on prices in whole units, currency upper-cased. */
+export declare function ticketTypeToMajor<T extends TypeLike>(type: T): T;
+/** Output: an event with `ticketTypes` converted by `ticketTypeToMajor`. */
+export declare function eventToMajor<T extends {
+    ticketTypes: TypeLike[];
+}>(event: T): T;
+/** Output: a ticket (or attendee) with `amount` (and add-on prices) in whole units of its own currency. */
+export declare function ticketToMajor<T extends {
+    amount: number;
+    currency: string;
+    addons?: Array<Priced & Record<string, unknown>>;
+}>(ticket: T): T;
+/** Input: a ticket type payload (agent, whole units) to minor units, using `fallbackCurrency` when it names none. */
+export declare function ticketTypeToMinor<T extends TypeLike>(type: T, fallbackCurrency?: string): T;
+export {};

package/dist/runtime/server/mcp/money.js

@@ -0,0 +1,42 @@
+import { fromCents, toCents } from "@frigear-nu/mcp/utils";
+import { DEFAULT_CURRENCY } from "../../utils/index.js";
+const currencyOf = (type) => (type.currency ?? DEFAULT_CURRENCY).toUpperCase();
+export function ticketTypeToMajor(type) {
+  const currency = currencyOf(type);
+  return {
+    ...type,
+    ...typeof type.price === "number" ? { price: fromCents(type.price, currency) } : {},
+    ...type.currency ? { currency } : {},
+    ...type.addonGroups ? {
+      addonGroups: type.addonGroups.map((group) => ({
+        ...group,
+        ...group.addons ? { addons: group.addons.map((addon) => typeof addon.price === "number" ? { ...addon, price: fromCents(addon.price, currency) } : addon) } : {}
+      }))
+    } : {}
+  };
+}
+export function eventToMajor(event) {
+  return { ...event, ticketTypes: event.ticketTypes.map(ticketTypeToMajor) };
+}
+export function ticketToMajor(ticket) {
+  const currency = ticket.currency.toUpperCase();
+  return {
+    ...ticket,
+    currency,
+    amount: fromCents(ticket.amount, currency),
+    ...Array.isArray(ticket.addons) ? { addons: ticket.addons.map((addon) => typeof addon.price === "number" ? { ...addon, price: fromCents(addon.price, currency) } : addon) } : {}
+  };
+}
+export function ticketTypeToMinor(type, fallbackCurrency = DEFAULT_CURRENCY) {
+  const currency = (type.currency ?? fallbackCurrency).toUpperCase();
+  return {
+    ...type,
+    ...typeof type.price === "number" ? { price: toCents(type.price, currency) } : {},
+    ...type.addonGroups ? {
+      addonGroups: type.addonGroups.map((group) => ({
+        ...group,
+        ...group.addons ? { addons: group.addons.map((addon) => typeof addon.price === "number" ? { ...addon, price: toCents(addon.price, currency) } : addon) } : {}
+      }))
+    } : {}
+  };
+}

package/dist/runtime/server/mcp/schemas.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const ticketTypeFields: z.ZodObject<{
+    currency: z.ZodOptional<z.ZodString>;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    key: z.ZodString;
+    price: z.ZodOptional<z.ZodNumber>;
+    hidePrice: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+    capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxPerUser: z.ZodOptional<z.ZodNumber>;
+    excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const eventFields: {
+    slug: z.ZodString;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+};
+export declare const createEventShape: {
+    ticketTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+        price: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+        hidePrice: z.ZodOptional<z.ZodBoolean>;
+        capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        maxPerUser: z.ZodOptional<z.ZodNumber>;
+        requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+        excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+        addonGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            title: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            sortOrder: z.ZodOptional<z.ZodNumber>;
+            addons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+                price: z.ZodOptional<z.ZodNumber>;
+                capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                sortOrder: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    slug: z.ZodString;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+};
+export declare const updateEventShape: {
+    id: z.ZodString;
+    patch: z.ZodObject<{
+        slug: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        body: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        image: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        location: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        locationUrl: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        startsAt: z.ZodOptional<z.ZodString>;
+        endsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            published: "published";
+            archived: "archived";
+        }>>>;
+        requiresMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+    }, z.core.$strip>;
+};
+export declare const updateTicketTypeShape: {
+    id: z.ZodString;
+    patch: z.ZodObject<{
+        currency: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        key: z.ZodOptional<z.ZodString>;
+        price: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        hidePrice: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        requiresMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+        capacity: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+        saleStartsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        saleEndsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        maxPerUser: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        excludesMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+        isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        sortOrder: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+};

package/dist/runtime/server/mcp/schemas.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { MONEY_NOTICE } from "@frigear-nu/mcp/utils";
+const text = z.union([z.string().min(1), z.record(z.string(), z.string())]).describe('Text in one language, or a locale -> text map such as {"en": "Party", "da": "Fest"}.');
+const membership = z.union([z.literal("any"), z.array(z.string())]).nullable().describe('"any", a list of plan keys, or null for no rule.');
+const isoDate = z.string().describe("ISO 8601 date-time, e.g. 2026-12-24T18:00:00Z.");
+const addon = z.object({
+  label: text,
+  description: text.nullish(),
+  price: z.number().min(0).optional().describe(`${MONEY_NOTICE} In the ticket type's currency.`),
+  capacity: z.number().int().min(0).nullish(),
+  sortOrder: z.number().int().optional()
+});
+const addonGroup = z.object({
+  title: text,
+  required: z.boolean().optional(),
+  multiple: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addons: z.array(addon).optional()
+});
+const ticketType = z.object({
+  key: z.string().min(1).max(64),
+  name: text,
+  description: text.nullish(),
+  price: z.number().min(0).optional().describe(MONEY_NOTICE),
+  currency: z.string().length(3).optional().describe("ISO 4217 code such as DKK or USD. The price is in this currency; defaults to DKK for new ticket types."),
+  hidePrice: z.boolean().optional(),
+  capacity: z.number().int().min(0).nullish(),
+  saleStartsAt: isoDate.nullish(),
+  saleEndsAt: isoDate.nullish(),
+  maxPerUser: z.number().int().min(1).optional(),
+  requiresMembership: membership.optional(),
+  excludesMembership: membership.optional(),
+  isDefault: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addonGroups: z.array(addonGroup).optional()
+});
+export const ticketTypeFields = ticketType.omit({ addonGroups: true });
+export const eventFields = {
+  slug: z.string().min(1).max(128).describe("Lowercase letters, numbers and dashes."),
+  name: text,
+  description: text.nullish(),
+  body: text.nullish(),
+  image: z.string().nullish(),
+  location: text.nullish(),
+  locationUrl: z.string().nullish(),
+  startsAt: isoDate,
+  endsAt: isoDate.nullish(),
+  status: z.enum(["draft", "published", "archived"]).optional(),
+  requiresMembership: membership.optional()
+};
+export const createEventShape = { ...eventFields, ticketTypes: z.array(ticketType).optional() };
+export const updateEventShape = {
+  id: z.string().describe("The event id."),
+  patch: z.object(eventFields).partial().describe("Only the fields to change.")
+};
+export const updateTicketTypeShape = {
+  id: z.string().describe("The ticket type id (see get-event or list-all-events)."),
+  patch: ticketTypeFields.partial().describe("Only the fields to change. Addon groups are not changed here.")
+};

package/dist/runtime/server/mcp/tools/admin/create-event.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/create-event.js

@@ -0,0 +1,12 @@
+import { createEventWithCatalog } from "../../../utils/admin.js";
+import { eventInput } from "../../../utils/admin-schemas.js";
+import { createEventShape } from "../../schemas.js";
+import { ticketTypeToMinor } from "../../money.js";
+export default defineScopedMcpTool({
+  description: "Create an event, optionally with ticket types, addon groups and addons (staff). Prices are in whole currency units (52.2 = 52.20), not cents.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { destructiveHint: false },
+  inputSchema: createEventShape,
+  handler: (args) => createEventWithCatalog(eventInput.parse({ ...args, ticketTypes: args.ticketTypes?.map((type) => ticketTypeToMinor(type)) }))
+});

package/dist/runtime/server/mcp/tools/admin/get-event-definition.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/get-event-definition.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { getEventWithTicketTypes } from "../../../utils/admin.js";
+import { eventToMajor } from "../../money.js";
+export default defineScopedMcpTool({
+  description: "Get one event with all its ticket types and their ids, whatever its status (staff). Use the ids with update-ticket-type. Prices are in whole currency units (52.2 = 52.20), not cents.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  inputSchema: { id: z.string().describe("The event id.") },
+  handler: async ({ id }) => eventToMajor(await getEventWithTicketTypes(id))
+});

package/dist/runtime/server/mcp/tools/admin/list-all-events.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/list-all-events.js

@@ -0,0 +1,9 @@
+import { db, schema } from "@nuxthub/db";
+import { desc } from "drizzle-orm";
+export default defineScopedMcpTool({
+  description: "List all events including drafts and archived ones (staff).",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  handler: () => db.select().from(schema.events).orderBy(desc(schema.events.startsAt))
+});

package/dist/runtime/server/mcp/tools/admin/list-attendees.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/list-attendees.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { db, schema } from "@nuxthub/db";
+import { asc, eq } from "drizzle-orm";
+import { ticketToMajor } from "../../money.js";
+export default defineScopedMcpTool({
+  description: "List the tickets of an event (staff). Attendee names and emails are only included with the events:pii scope. Amounts are in whole currency units (52.2 = 52.20), not cents.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  inputSchema: { eventId: z.string().describe("The event id.") },
+  handler: async ({ eventId }, ctx) => {
+    const rows = await db.select({
+      ticket: schema.eventTickets,
+      userName: schema.users.name,
+      userEmail: schema.users.email
+    }).from(schema.eventTickets).leftJoin(schema.users, eq(schema.eventTickets.userId, schema.users.id)).where(eq(schema.eventTickets.eventId, eventId)).orderBy(asc(schema.eventTickets.createdAt));
+    const allow = ctx.hasScope("events:pii");
+    const attendees = rows.map(({ ticket, userName, userEmail }) => redactPii({
+      ...ticketToMajor(pick(ticket, ["id", "ticketTypeId", "status", "amount", "currency", "checkedInAt", "createdAt"])),
+      addons: ticket.addons.length,
+      userName,
+      userEmail
+    }, { allow, fields: ["userName", "userEmail"] }));
+    return { notice: piiNotice(allow, "events:pii", "Attendee names and emails"), attendees };
+  }
+});

package/dist/runtime/server/mcp/tools/admin/update-event.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/update-event.js

@@ -0,0 +1,10 @@
+import { eventPatchSchema, patchEventRow } from "../../../utils/admin.js";
+import { updateEventShape } from "../../schemas.js";
+export default defineScopedMcpTool({
+  description: "Update fields of an event (staff). Only the given fields change.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { idempotentHint: true },
+  inputSchema: updateEventShape,
+  handler: ({ id, patch }) => patchEventRow(id, eventPatchSchema.parse(patch))
+});

package/dist/runtime/server/mcp/tools/admin/update-ticket-type.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;