@burdenoff/mcp-libs 2026.626.1 → 2026.627.2

package/dist/modules/eventfullymanaged/index.js

@@ -0,0 +1,3303 @@
+import { mcpToolName, jsonResult, errorResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/eventfullymanaged/operations.ts
+var EVENT_FIELDS = `
+  id name description type status visibility timezone startAt endAt capacity
+  metadata workspaceId createdAt updatedAt
+`;
+var VENUE_FIELDS = `
+  id name description addressLine1 city state country postalCode capacity
+  amenities status openingHours pricing metadata workspaceId createdAt updatedAt
+`;
+var FLOOR_PLAN_FIELDS = `
+  id name venueId imageUrl dimensions interactiveAreas workspaceId
+  createdAt updatedAt
+`;
+var EVENT_SESSION_FIELDS = `
+  id eventId title description sessionType track status startsAt endsAt capacity
+  venueId metadata workspaceId createdAt updatedAt
+`;
+var SPEAKER_FIELDS = `
+  id fullName title organization bio email phone avatarUrl socialLinks
+  workspaceId createdAt updatedAt
+`;
+var ATTENDEE_FIELDS = `
+  id eventId fullName email phone company role tags profile metadata
+  workspaceId createdAt updatedAt
+`;
+var REGISTRATION_FIELDS = `
+  id eventId attendeeId ticketTypeId status quantity totalAmount currency
+  registeredAt checkedInAt metadata workspaceId createdAt updatedAt
+`;
+var TICKET_TYPE_FIELDS = `
+  id eventId name description price currency capacity soldCount isActive
+  salesStartAt salesEndAt metadata workspaceId createdAt updatedAt
+`;
+var PROMO_CODE_FIELDS = `
+  id eventId code description discountType discountValue maxUses usedCount
+  isActive startsAt endsAt metadata workspaceId createdAt updatedAt
+`;
+var SPONSOR_FIELDS = `
+  id eventId name level logoUrl website contactName contactEmail contactPhone
+  metrics metadata workspaceId createdAt updatedAt
+`;
+var EXHIBITOR_FIELDS = `
+  id eventId name category boothCode contactName contactEmail status metadata
+  workspaceId createdAt updatedAt
+`;
+var LEAD_FIELDS = `
+  id eventId exhibitorId sponsorId attendeeName attendeeEmail score status notes
+  capturedAt metadata workspaceId createdAt updatedAt
+`;
+var CHECK_IN_STATION_FIELDS = `
+  id eventId name code location isActive kioskConfig metadata workspaceId
+  createdAt updatedAt
+`;
+var CHECK_IN_RECORD_FIELDS = `
+  id eventId registrationId attendeeId stationId direction method status
+  recordedAt metadata workspaceId createdAt updatedAt
+`;
+var NETWORKING_PROFILE_FIELDS = `
+  id eventId attendeeId industry role interests lookingFor visibility metadata
+  workspaceId createdAt updatedAt
+`;
+var NETWORKING_MATCH_FIELDS = `
+  id eventId sourceProfileId targetProfileId score reason status metadata
+  workspaceId createdAt updatedAt
+`;
+var MEETING_FIELDS = `
+  id eventId sourceProfileId targetProfileId title status location notes
+  startsAt endsAt metadata workspaceId createdAt updatedAt
+`;
+var SIMPLE_ENTITY_FIELDS = `
+  id name title status eventId metadata workspaceId createdAt updatedAt
+`;
+var DASHBOARD_SUMMARY_FIELDS = `
+  totalEvents activeEvents totalVenues totalRegistrations totalAttendees
+  totalSponsors upcomingSessions
+  latestEvents { id name status startAt endAt }
+`;
+var GET_EVENT = `
+  query EventfullymanagedGetEvent($id: ID!) {
+    eventfullyManagedEvent(id: $id) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var LIST_EVENTS = `
+  query EventfullymanagedListEvents(
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedEvents(
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${EVENT_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_EVENT = `
+  mutation EventfullymanagedCreateEvent($input: EventfullyManagedEventInput!) {
+    eventfullyManagedCreateEvent(input: $input) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var UPDATE_EVENT = `
+  mutation EventfullymanagedUpdateEvent($id: ID!, $input: EventfullyManagedEventInput!) {
+    eventfullyManagedUpdateEvent(id: $id, input: $input) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var DELETE_EVENT = `
+  mutation EventfullymanagedDeleteEvent($id: ID!) {
+    eventfullyManagedDeleteEvent(id: $id)
+  }
+`;
+var GET_VENUE = `
+  query EventfullymanagedGetVenue($id: ID!) {
+    eventfullyManagedVenue(id: $id) {
+      ${VENUE_FIELDS}
+    }
+  }
+`;
+var LIST_VENUES = `
+  query EventfullymanagedListVenues(
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedVenues(
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${VENUE_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_VENUE = `
+  mutation EventfullymanagedCreateVenue($input: EventfullyManagedVenueInput!) {
+    eventfullyManagedCreateVenue(input: $input) {
+      ${VENUE_FIELDS}
+    }
+  }
+`;
+var UPDATE_VENUE = `
+  mutation EventfullymanagedUpdateVenue($id: ID!, $input: EventfullyManagedVenueInput!) {
+    eventfullyManagedUpdateVenue(id: $id, input: $input) {
+      ${VENUE_FIELDS}
+    }
+  }
+`;
+var DELETE_VENUE = `
+  mutation EventfullymanagedDeleteVenue($id: ID!) {
+    eventfullyManagedDeleteVenue(id: $id)
+  }
+`;
+var LIST_FLOOR_PLANS = `
+  query EventfullymanagedListFloorPlans(
+    $venueId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedFloorPlans(
+      venueId: $venueId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${FLOOR_PLAN_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_FLOOR_PLAN = `
+  mutation EventfullymanagedCreateFloorPlan($input: EventfullyManagedFloorPlanInput!) {
+    eventfullyManagedCreateFloorPlan(input: $input) {
+      ${FLOOR_PLAN_FIELDS}
+    }
+  }
+`;
+var UPDATE_FLOOR_PLAN = `
+  mutation EventfullymanagedUpdateFloorPlan(
+    $id: ID!
+    $input: EventfullyManagedFloorPlanInput!
+  ) {
+    eventfullyManagedUpdateFloorPlan(id: $id, input: $input) {
+      ${FLOOR_PLAN_FIELDS}
+    }
+  }
+`;
+var LIST_EVENT_SESSIONS = `
+  query EventfullymanagedListEventSessions(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedEventSessions(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${EVENT_SESSION_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_EVENT_SESSION = `
+  mutation EventfullymanagedCreateEventSession(
+    $input: EventfullyManagedEventSessionInput!
+  ) {
+    eventfullyManagedCreateEventSession(input: $input) {
+      ${EVENT_SESSION_FIELDS}
+    }
+  }
+`;
+var UPDATE_EVENT_SESSION = `
+  mutation EventfullymanagedUpdateEventSession(
+    $id: ID!
+    $input: EventfullyManagedEventSessionInput!
+  ) {
+    eventfullyManagedUpdateEventSession(id: $id, input: $input) {
+      ${EVENT_SESSION_FIELDS}
+    }
+  }
+`;
+var LIST_SPEAKERS = `
+  query EventfullymanagedListSpeakers($workspaceId: ID, $limit: Int, $offset: Int) {
+    eventfullyManagedSpeakers(workspaceId: $workspaceId, limit: $limit, offset: $offset) {
+      items { ${SPEAKER_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_SPEAKER = `
+  mutation EventfullymanagedCreateSpeaker($input: EventfullyManagedSpeakerInput!) {
+    eventfullyManagedCreateSpeaker(input: $input) {
+      ${SPEAKER_FIELDS}
+    }
+  }
+`;
+var UPDATE_SPEAKER = `
+  mutation EventfullymanagedUpdateSpeaker($id: ID!, $input: EventfullyManagedSpeakerInput!) {
+    eventfullyManagedUpdateSpeaker(id: $id, input: $input) {
+      ${SPEAKER_FIELDS}
+    }
+  }
+`;
+var LIST_ATTENDEES = `
+  query EventfullymanagedListAttendees(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedAttendees(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${ATTENDEE_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_ATTENDEE = `
+  mutation EventfullymanagedCreateAttendee($input: EventfullyManagedAttendeeInput!) {
+    eventfullyManagedCreateAttendee(input: $input) {
+      ${ATTENDEE_FIELDS}
+    }
+  }
+`;
+var UPDATE_ATTENDEE = `
+  mutation EventfullymanagedUpdateAttendee(
+    $id: ID!
+    $input: EventfullyManagedAttendeeInput!
+  ) {
+    eventfullyManagedUpdateAttendee(id: $id, input: $input) {
+      ${ATTENDEE_FIELDS}
+    }
+  }
+`;
+var LIST_REGISTRATIONS = `
+  query EventfullymanagedListRegistrations(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedRegistrations(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${REGISTRATION_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_REGISTRATION = `
+  mutation EventfullymanagedCreateRegistration(
+    $input: EventfullyManagedRegistrationInput!
+  ) {
+    eventfullyManagedCreateRegistration(input: $input) {
+      ${REGISTRATION_FIELDS}
+    }
+  }
+`;
+var UPDATE_REGISTRATION = `
+  mutation EventfullymanagedUpdateRegistration(
+    $id: ID!
+    $input: EventfullyManagedRegistrationInput!
+  ) {
+    eventfullyManagedUpdateRegistration(id: $id, input: $input) {
+      ${REGISTRATION_FIELDS}
+    }
+  }
+`;
+var LIST_TICKET_TYPES = `
+  query EventfullymanagedListTicketTypes(
+    $eventId: ID
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedTicketTypes(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${TICKET_TYPE_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_TICKET_TYPE = `
+  mutation EventfullymanagedCreateTicketType(
+    $input: EventfullyManagedTicketTypeInput!
+  ) {
+    eventfullyManagedCreateTicketType(input: $input) {
+      ${TICKET_TYPE_FIELDS}
+    }
+  }
+`;
+var UPDATE_TICKET_TYPE = `
+  mutation EventfullymanagedUpdateTicketType(
+    $id: ID!
+    $input: EventfullyManagedTicketTypeInput!
+  ) {
+    eventfullyManagedUpdateTicketType(id: $id, input: $input) {
+      ${TICKET_TYPE_FIELDS}
+    }
+  }
+`;
+var DELETE_TICKET_TYPE = `
+  mutation EventfullymanagedDeleteTicketType($id: ID!) {
+    eventfullyManagedDeleteTicketType(id: $id)
+  }
+`;
+var LIST_PROMO_CODES = `
+  query EventfullymanagedListPromoCodes(
+    $eventId: ID
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedPromoCodes(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${PROMO_CODE_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_PROMO_CODE = `
+  mutation EventfullymanagedCreatePromoCode($input: EventfullyManagedPromoCodeInput!) {
+    eventfullyManagedCreatePromoCode(input: $input) {
+      ${PROMO_CODE_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROMO_CODE = `
+  mutation EventfullymanagedUpdatePromoCode(
+    $id: ID!
+    $input: EventfullyManagedPromoCodeInput!
+  ) {
+    eventfullyManagedUpdatePromoCode(id: $id, input: $input) {
+      ${PROMO_CODE_FIELDS}
+    }
+  }
+`;
+var DELETE_PROMO_CODE = `
+  mutation EventfullymanagedDeletePromoCode($id: ID!) {
+    eventfullyManagedDeletePromoCode(id: $id)
+  }
+`;
+var GET_SPONSOR = `
+  query EventfullymanagedGetSponsor($id: ID!) {
+    eventfullyManagedSponsor(id: $id) {
+      ${SPONSOR_FIELDS}
+    }
+  }
+`;
+var LIST_SPONSORS = `
+  query EventfullymanagedListSponsors(
+    $eventId: ID
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedSponsors(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SPONSOR_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_SPONSOR = `
+  mutation EventfullymanagedCreateSponsor($input: EventfullyManagedSponsorInput!) {
+    eventfullyManagedCreateSponsor(input: $input) {
+      ${SPONSOR_FIELDS}
+    }
+  }
+`;
+var UPDATE_SPONSOR = `
+  mutation EventfullymanagedUpdateSponsor($id: ID!, $input: EventfullyManagedSponsorInput!) {
+    eventfullyManagedUpdateSponsor(id: $id, input: $input) {
+      ${SPONSOR_FIELDS}
+    }
+  }
+`;
+var DELETE_SPONSOR = `
+  mutation EventfullymanagedDeleteSponsor($id: ID!) {
+    eventfullyManagedDeleteSponsor(id: $id)
+  }
+`;
+var LIST_EXHIBITORS = `
+  query EventfullymanagedListExhibitors(
+    $eventId: ID
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedExhibitors(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${EXHIBITOR_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_EXHIBITOR = `
+  mutation EventfullymanagedCreateExhibitor($input: EventfullyManagedExhibitorInput!) {
+    eventfullyManagedCreateExhibitor(input: $input) {
+      ${EXHIBITOR_FIELDS}
+    }
+  }
+`;
+var UPDATE_EXHIBITOR = `
+  mutation EventfullymanagedUpdateExhibitor(
+    $id: ID!
+    $input: EventfullyManagedExhibitorInput!
+  ) {
+    eventfullyManagedUpdateExhibitor(id: $id, input: $input) {
+      ${EXHIBITOR_FIELDS}
+    }
+  }
+`;
+var DELETE_EXHIBITOR = `
+  mutation EventfullymanagedDeleteExhibitor($id: ID!) {
+    eventfullyManagedDeleteExhibitor(id: $id)
+  }
+`;
+var LIST_LEADS = `
+  query EventfullymanagedListLeads(
+    $eventId: ID
+    $workspaceId: ID
+    $search: String
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedLeads(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      search: $search
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${LEAD_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_LEAD = `
+  mutation EventfullymanagedCreateLead($input: EventfullyManagedLeadInput!) {
+    eventfullyManagedCreateLead(input: $input) {
+      ${LEAD_FIELDS}
+    }
+  }
+`;
+var UPDATE_LEAD = `
+  mutation EventfullymanagedUpdateLead($id: ID!, $input: EventfullyManagedLeadInput!) {
+    eventfullyManagedUpdateLead(id: $id, input: $input) {
+      ${LEAD_FIELDS}
+    }
+  }
+`;
+var DELETE_LEAD = `
+  mutation EventfullymanagedDeleteLead($id: ID!) {
+    eventfullyManagedDeleteLead(id: $id)
+  }
+`;
+var LIST_CHECK_IN_STATIONS = `
+  query EventfullymanagedListCheckInStations(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedCheckInStations(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_CHECK_IN_STATION = `
+  mutation EventfullymanagedCreateCheckInStation(
+    $input: EventfullyManagedCheckInStationInput!
+  ) {
+    eventfullyManagedCreateCheckInStation(input: $input) {
+      ${CHECK_IN_STATION_FIELDS}
+    }
+  }
+`;
+var UPDATE_CHECK_IN_STATION = `
+  mutation EventfullymanagedUpdateCheckInStation(
+    $id: ID!
+    $input: EventfullyManagedCheckInStationInput!
+  ) {
+    eventfullyManagedUpdateCheckInStation(id: $id, input: $input) {
+      ${CHECK_IN_STATION_FIELDS}
+    }
+  }
+`;
+var DELETE_CHECK_IN_STATION = `
+  mutation EventfullymanagedDeleteCheckInStation($id: ID!) {
+    eventfullyManagedDeleteCheckInStation(id: $id)
+  }
+`;
+var LIST_CHECK_IN_RECORDS = `
+  query EventfullymanagedListCheckInRecords(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedCheckInRecords(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${CHECK_IN_RECORD_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_CHECK_IN_RECORD = `
+  mutation EventfullymanagedCreateCheckInRecord(
+    $input: EventfullyManagedCheckInRecordInput!
+  ) {
+    eventfullyManagedCreateCheckInRecord(input: $input) {
+      ${CHECK_IN_RECORD_FIELDS}
+    }
+  }
+`;
+var UPDATE_CHECK_IN_RECORD = `
+  mutation EventfullymanagedUpdateCheckInRecord(
+    $id: ID!
+    $input: EventfullyManagedCheckInRecordInput!
+  ) {
+    eventfullyManagedUpdateCheckInRecord(id: $id, input: $input) {
+      ${CHECK_IN_RECORD_FIELDS}
+    }
+  }
+`;
+var DELETE_CHECK_IN_RECORD = `
+  mutation EventfullymanagedDeleteCheckInRecord($id: ID!) {
+    eventfullyManagedDeleteCheckInRecord(id: $id)
+  }
+`;
+var LIST_NETWORKING_PROFILES = `
+  query EventfullymanagedListNetworkingProfiles(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedNetworkingProfiles(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${NETWORKING_PROFILE_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_NETWORKING_PROFILE = `
+  mutation EventfullymanagedCreateNetworkingProfile(
+    $input: EventfullyManagedNetworkingProfileInput!
+  ) {
+    eventfullyManagedCreateNetworkingProfile(input: $input) {
+      ${NETWORKING_PROFILE_FIELDS}
+    }
+  }
+`;
+var UPDATE_NETWORKING_PROFILE = `
+  mutation EventfullymanagedUpdateNetworkingProfile(
+    $id: ID!
+    $input: EventfullyManagedNetworkingProfileInput!
+  ) {
+    eventfullyManagedUpdateNetworkingProfile(id: $id, input: $input) {
+      ${NETWORKING_PROFILE_FIELDS}
+    }
+  }
+`;
+var DELETE_NETWORKING_PROFILE = `
+  mutation EventfullymanagedDeleteNetworkingProfile($id: ID!) {
+    eventfullyManagedDeleteNetworkingProfile(id: $id)
+  }
+`;
+var LIST_NETWORKING_MATCHES = `
+  query EventfullymanagedListNetworkingMatches(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedNetworkingMatches(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_NETWORKING_MATCH = `
+  mutation EventfullymanagedCreateNetworkingMatch(
+    $input: EventfullyManagedNetworkingMatchInput!
+  ) {
+    eventfullyManagedCreateNetworkingMatch(input: $input) {
+      ${NETWORKING_MATCH_FIELDS}
+    }
+  }
+`;
+var UPDATE_NETWORKING_MATCH = `
+  mutation EventfullymanagedUpdateNetworkingMatch(
+    $id: ID!
+    $input: EventfullyManagedNetworkingMatchInput!
+  ) {
+    eventfullyManagedUpdateNetworkingMatch(id: $id, input: $input) {
+      ${NETWORKING_MATCH_FIELDS}
+    }
+  }
+`;
+var DELETE_NETWORKING_MATCH = `
+  mutation EventfullymanagedDeleteNetworkingMatch($id: ID!) {
+    eventfullyManagedDeleteNetworkingMatch(id: $id)
+  }
+`;
+var LIST_MEETINGS = `
+  query EventfullymanagedListMeetings(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedMeetings(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var CREATE_MEETING = `
+  mutation EventfullymanagedCreateMeeting($input: EventfullyManagedMeetingInput!) {
+    eventfullyManagedCreateMeeting(input: $input) {
+      ${MEETING_FIELDS}
+    }
+  }
+`;
+var UPDATE_MEETING = `
+  mutation EventfullymanagedUpdateMeeting($id: ID!, $input: EventfullyManagedMeetingInput!) {
+    eventfullyManagedUpdateMeeting(id: $id, input: $input) {
+      ${MEETING_FIELDS}
+    }
+  }
+`;
+var DELETE_MEETING = `
+  mutation EventfullymanagedDeleteMeeting($id: ID!) {
+    eventfullyManagedDeleteMeeting(id: $id)
+  }
+`;
+var LIST_ANNOUNCEMENTS = `
+  query EventfullymanagedListAnnouncements(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedAnnouncements(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var UPSERT_ANNOUNCEMENT = `
+  mutation EventfullymanagedUpsertAnnouncement(
+    $id: ID
+    $input: EventfullyManagedSimpleEntityInput!
+  ) {
+    eventfullyManagedUpsertAnnouncement(id: $id, input: $input) {
+      ${SIMPLE_ENTITY_FIELDS}
+    }
+  }
+`;
+var LIST_AUTOMATION_RULES = `
+  query EventfullymanagedListAutomationRules(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedAutomationRules(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var UPSERT_AUTOMATION_RULE = `
+  mutation EventfullymanagedUpsertAutomationRule(
+    $id: ID
+    $input: EventfullyManagedSimpleEntityInput!
+  ) {
+    eventfullyManagedUpsertAutomationRule(id: $id, input: $input) {
+      ${SIMPLE_ENTITY_FIELDS}
+    }
+  }
+`;
+var LIST_COMMUNICATION_CAMPAIGNS = `
+  query EventfullymanagedListCommunicationCampaigns(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedCommunicationCampaigns(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var UPSERT_COMMUNICATION_CAMPAIGN = `
+  mutation EventfullymanagedUpsertCommunicationCampaign(
+    $id: ID
+    $input: EventfullyManagedSimpleEntityInput!
+  ) {
+    eventfullyManagedUpsertCommunicationCampaign(id: $id, input: $input) {
+      ${SIMPLE_ENTITY_FIELDS}
+    }
+  }
+`;
+var LIST_WORKFLOW_TEMPLATES = `
+  query EventfullymanagedListWorkflowTemplates(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedWorkflowTemplates(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var UPSERT_WORKFLOW_TEMPLATE = `
+  mutation EventfullymanagedUpsertWorkflowTemplate(
+    $id: ID
+    $input: EventfullyManagedSimpleEntityInput!
+  ) {
+    eventfullyManagedUpsertWorkflowTemplate(id: $id, input: $input) {
+      ${SIMPLE_ENTITY_FIELDS}
+    }
+  }
+`;
+var LIST_ANALYTICS_SNAPSHOTS = `
+  query EventfullymanagedListAnalyticsSnapshots(
+    $eventId: ID
+    $workspaceId: ID
+    $limit: Int
+    $offset: Int
+  ) {
+    eventfullyManagedAnalyticsSnapshots(
+      eventId: $eventId
+      workspaceId: $workspaceId
+      limit: $limit
+      offset: $offset
+    ) {
+      items { ${SIMPLE_ENTITY_FIELDS} }
+      total
+    }
+  }
+`;
+var UPSERT_ANALYTICS_SNAPSHOT = `
+  mutation EventfullymanagedUpsertAnalyticsSnapshot(
+    $id: ID
+    $input: EventfullyManagedSimpleEntityInput!
+  ) {
+    eventfullyManagedUpsertAnalyticsSnapshot(id: $id, input: $input) {
+      ${SIMPLE_ENTITY_FIELDS}
+    }
+  }
+`;
+var DASHBOARD_SUMMARY = `
+  query EventfullymanagedDashboardSummary($workspaceId: ID) {
+    eventfullyManagedDashboardSummary(workspaceId: $workspaceId) {
+      ${DASHBOARD_SUMMARY_FIELDS}
+    }
+  }
+`;
+var JsonObject = z.record(z.string(), z.unknown());
+var PaginationShape = {
+  workspaceId: z.string().optional().describe("Optional workspace ID filter (defaults to the gateway-bound workspace)"),
+  limit: z.number().int().optional().describe("Page size"),
+  offset: z.number().int().optional().describe("Pagination offset (default 0)")
+};
+function listVars(args, keys) {
+  const out = {};
+  for (const k of keys) {
+    if (args[k] !== void 0) out[k] = args[k];
+  }
+  return out;
+}
+function buildInput(args, keys) {
+  const input = {};
+  for (const k of keys) {
+    if (args[k] !== void 0) input[k] = args[k];
+  }
+  return input;
+}
+
+// src/modules/eventfullymanaged/tools/events.ts
+var EVENT_INPUT_KEYS = [
+  "name",
+  "description",
+  "type",
+  "status",
+  "visibility",
+  "timezone",
+  "startAt",
+  "endAt",
+  "capacity",
+  "metadata"
+];
+function registerEventTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_list")),
+    {
+      title: "List Events",
+      description: "List events in the bound workspace, optionally filtered by free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        search: z.string().optional().describe("Free-text search across event name/description"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EVENTS, listVars(args, ["search", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedEvents);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged events_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_get")),
+    {
+      title: "Get Event",
+      description: "Fetch a single event by ID.",
+      inputSchema: { id: z.string().describe("Event ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_EVENT, { id });
+        if (!data.eventfullyManagedEvent) return errorResult(`Event ${id} not found`);
+        return jsonResult(data.eventfullyManagedEvent);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged events_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_create")),
+    {
+      title: "Create Event",
+      description: 'Create an event. `startAt`/`endAt` are ISO-8601 timestamps; `timezone` is an IANA tz (e.g. "Asia/Kolkata"); `type` is e.g. "conference"/"workshop"/"webinar".',
+      inputSchema: {
+        name: z.string().min(1).describe("Event name"),
+        type: z.string().min(1).describe('Event type, e.g. "conference", "workshop", "webinar"'),
+        timezone: z.string().min(1).describe('IANA timezone, e.g. "Asia/Kolkata"'),
+        startAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        description: z.string().optional().describe("Event description"),
+        status: z.string().optional().describe('Lifecycle status, e.g. "draft", "published"'),
+        visibility: z.string().optional().describe('Visibility, e.g. "public", "private"'),
+        capacity: z.number().int().optional().describe("Maximum capacity"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, EVENT_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_EVENT, { input });
+        return jsonResult(data.eventfullyManagedCreateEvent);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged events_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_update")),
+    {
+      title: "Update Event",
+      description: "Update an event. The backend reuses the full event input, so the required fields (name, type, timezone, startAt, endAt) must be re-supplied.",
+      inputSchema: {
+        id: z.string().describe("Event ID"),
+        name: z.string().min(1).describe("Event name"),
+        type: z.string().min(1).describe("Event type"),
+        timezone: z.string().min(1).describe("IANA timezone"),
+        startAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        description: z.string().optional().describe("Event description"),
+        status: z.string().optional().describe("Lifecycle status"),
+        visibility: z.string().optional().describe("Visibility"),
+        capacity: z.number().int().optional().describe("Maximum capacity"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, EVENT_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_EVENT, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateEvent);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged events_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_delete")),
+    {
+      title: "Delete Event",
+      description: "Delete an event by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Event ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_EVENT,
+          { id }
+        );
+        return jsonResult({ deleted: data.eventfullyManagedDeleteEvent, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged events_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var VENUE_INPUT_KEYS = [
+  "name",
+  "description",
+  "addressLine1",
+  "city",
+  "state",
+  "country",
+  "postalCode",
+  "capacity",
+  "amenities",
+  "status",
+  "openingHours",
+  "pricing",
+  "metadata"
+];
+var FLOOR_PLAN_INPUT_KEYS = [
+  "name",
+  "venueId",
+  "imageUrl",
+  "dimensions",
+  "interactiveAreas"
+];
+function registerVenueTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "venues_list")),
+    {
+      title: "List Venues",
+      description: "List venues, optionally filtered by free-text search, with pagination.",
+      inputSchema: {
+        search: z.string().optional().describe("Free-text search across venue name/address"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_VENUES, listVars(args, ["search", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedVenues);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged venues_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list venues: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "venues_get")),
+    {
+      title: "Get Venue",
+      description: "Fetch a single venue by ID.",
+      inputSchema: { id: z.string().describe("Venue ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_VENUE, { id });
+        if (!data.eventfullyManagedVenue) return errorResult(`Venue ${id} not found`);
+        return jsonResult(data.eventfullyManagedVenue);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged venues_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get venue: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "venues_create")),
+    {
+      title: "Create Venue",
+      description: "Create a venue. Only `name` is required; address/capacity/JSON fields are optional.",
+      inputSchema: {
+        name: z.string().min(1).describe("Venue name"),
+        description: z.string().optional().describe("Venue description"),
+        addressLine1: z.string().optional().describe("Street address"),
+        city: z.string().optional().describe("City"),
+        state: z.string().optional().describe("State/region"),
+        country: z.string().optional().describe("Country"),
+        postalCode: z.string().optional().describe("Postal code"),
+        capacity: z.number().int().optional().describe("Maximum capacity"),
+        amenities: z.array(z.string()).optional().describe("Amenity tags"),
+        status: z.string().optional().describe('Status, e.g. "active", "inactive"'),
+        openingHours: JsonObject.optional().describe("Opening-hours JSON"),
+        pricing: JsonObject.optional().describe("Pricing JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, VENUE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_VENUE, { input });
+        return jsonResult(data.eventfullyManagedCreateVenue);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged venues_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create venue: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "venues_update")),
+    {
+      title: "Update Venue",
+      description: "Update a venue. `name` is required by the backend input; other fields are optional.",
+      inputSchema: {
+        id: z.string().describe("Venue ID"),
+        name: z.string().min(1).describe("Venue name"),
+        description: z.string().optional().describe("Venue description"),
+        addressLine1: z.string().optional().describe("Street address"),
+        city: z.string().optional().describe("City"),
+        state: z.string().optional().describe("State/region"),
+        country: z.string().optional().describe("Country"),
+        postalCode: z.string().optional().describe("Postal code"),
+        capacity: z.number().int().optional().describe("Maximum capacity"),
+        amenities: z.array(z.string()).optional().describe("Amenity tags"),
+        status: z.string().optional().describe("Status"),
+        openingHours: JsonObject.optional().describe("Opening-hours JSON"),
+        pricing: JsonObject.optional().describe("Pricing JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, VENUE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_VENUE, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateVenue);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged venues_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update venue: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "venues_delete")),
+    {
+      title: "Delete Venue",
+      description: "Delete a venue by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Venue ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_VENUE,
+          { id }
+        );
+        return jsonResult({ deleted: data.eventfullyManagedDeleteVenue, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged venues_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete venue: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "floor_plans_list")),
+    {
+      title: "List Floor Plans",
+      description: "List floor plans, optionally filtered by venue, with pagination.",
+      inputSchema: {
+        venueId: z.string().optional().describe("Filter by venue ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_FLOOR_PLANS, listVars(args, ["venueId", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedFloorPlans);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged floor_plans_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list floor plans: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "floor_plans_create")),
+    {
+      title: "Create Floor Plan",
+      description: "Create a floor plan for a venue. `dimensions` and `interactiveAreas` are JSON describing the layout.",
+      inputSchema: {
+        name: z.string().min(1).describe("Floor-plan name"),
+        venueId: z.string().min(1).describe("Owning venue ID"),
+        imageUrl: z.string().optional().describe("Background image URL"),
+        dimensions: JsonObject.optional().describe("Dimensions JSON ({ width, height, ... })"),
+        interactiveAreas: z.union([JsonObject, z.array(z.unknown())]).optional().describe("Interactive-areas JSON (clickable booths/zones)")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, FLOOR_PLAN_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_FLOOR_PLAN, { input });
+        return jsonResult(data.eventfullyManagedCreateFloorPlan);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged floor_plans_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create floor plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "floor_plans_update")),
+    {
+      title: "Update Floor Plan",
+      description: "Update a floor plan. `name` and `venueId` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Floor-plan ID"),
+        name: z.string().min(1).describe("Floor-plan name"),
+        venueId: z.string().min(1).describe("Owning venue ID"),
+        imageUrl: z.string().optional().describe("Background image URL"),
+        dimensions: JsonObject.optional().describe("Dimensions JSON"),
+        interactiveAreas: z.union([JsonObject, z.array(z.unknown())]).optional().describe("Interactive-areas JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, FLOOR_PLAN_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_FLOOR_PLAN, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateFloorPlan);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged floor_plans_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update floor plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var SESSION_INPUT_KEYS = [
+  "eventId",
+  "title",
+  "description",
+  "sessionType",
+  "track",
+  "status",
+  "startsAt",
+  "endsAt",
+  "capacity",
+  "venueId",
+  "metadata"
+];
+var SPEAKER_INPUT_KEYS = [
+  "fullName",
+  "title",
+  "organization",
+  "bio",
+  "email",
+  "phone",
+  "avatarUrl",
+  "socialLinks"
+];
+function registerAgendaTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_list")),
+    {
+      title: "List Agenda Sessions",
+      description: "List agenda/program sessions, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EVENT_SESSIONS, listVars(args, ["eventId", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedEventSessions);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sessions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list agenda sessions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_create")),
+    {
+      title: "Create Agenda Session",
+      description: 'Create an agenda session for an event. `sessionType` is e.g. "keynote"/"talk"/"panel"/"break".',
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        title: z.string().min(1).describe("Session title"),
+        sessionType: z.string().min(1).describe('Session type, e.g. "keynote", "talk", "panel"'),
+        startsAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endsAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        description: z.string().optional().describe("Session description"),
+        track: z.string().optional().describe("Agenda track/room"),
+        status: z.string().optional().describe('Status, e.g. "scheduled", "cancelled"'),
+        capacity: z.number().int().optional().describe("Session capacity"),
+        venueId: z.string().optional().describe("Venue/room ID"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, SESSION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_EVENT_SESSION, { input });
+        return jsonResult(data.eventfullyManagedCreateEventSession);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sessions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create agenda session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_update")),
+    {
+      title: "Update Agenda Session",
+      description: "Update an agenda session. The backend reuses the full session input, so `eventId`, `title`, `sessionType`, `startsAt`, `endsAt` must be re-supplied.",
+      inputSchema: {
+        id: z.string().describe("Agenda session ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        title: z.string().min(1).describe("Session title"),
+        sessionType: z.string().min(1).describe("Session type"),
+        startsAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endsAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        description: z.string().optional().describe("Session description"),
+        track: z.string().optional().describe("Agenda track/room"),
+        status: z.string().optional().describe("Status"),
+        capacity: z.number().int().optional().describe("Session capacity"),
+        venueId: z.string().optional().describe("Venue/room ID"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, SESSION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_EVENT_SESSION, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateEventSession);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sessions_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update agenda session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "speakers_list")),
+    {
+      title: "List Speakers",
+      description: "List speakers in the workspace, with pagination. Returns items + total.",
+      inputSchema: { ...PaginationShape }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SPEAKERS, listVars(args, ["workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedSpeakers);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged speakers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list speakers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "speakers_create")),
+    {
+      title: "Create Speaker",
+      description: "Create a speaker profile. Only `fullName` is required.",
+      inputSchema: {
+        fullName: z.string().min(1).describe("Speaker full name"),
+        title: z.string().optional().describe("Job title"),
+        organization: z.string().optional().describe("Organization/company"),
+        bio: z.string().optional().describe("Speaker bio"),
+        email: z.string().optional().describe("Contact email"),
+        phone: z.string().optional().describe("Contact phone"),
+        avatarUrl: z.string().optional().describe("Avatar image URL"),
+        socialLinks: JsonObject.optional().describe(
+          "Social links JSON ({ twitter, linkedin, ... })"
+        )
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, SPEAKER_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_SPEAKER, { input });
+        return jsonResult(data.eventfullyManagedCreateSpeaker);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged speakers_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create speaker: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "speakers_update")),
+    {
+      title: "Update Speaker",
+      description: "Update a speaker profile. `fullName` is required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Speaker ID"),
+        fullName: z.string().min(1).describe("Speaker full name"),
+        title: z.string().optional().describe("Job title"),
+        organization: z.string().optional().describe("Organization/company"),
+        bio: z.string().optional().describe("Speaker bio"),
+        email: z.string().optional().describe("Contact email"),
+        phone: z.string().optional().describe("Contact phone"),
+        avatarUrl: z.string().optional().describe("Avatar image URL"),
+        socialLinks: JsonObject.optional().describe("Social links JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, SPEAKER_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_SPEAKER, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateSpeaker);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged speakers_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update speaker: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var ATTENDEE_INPUT_KEYS = [
+  "eventId",
+  "fullName",
+  "email",
+  "phone",
+  "company",
+  "role",
+  "tags",
+  "profile",
+  "metadata"
+];
+var REGISTRATION_INPUT_KEYS = [
+  "eventId",
+  "attendeeId",
+  "ticketTypeId",
+  "status",
+  "quantity",
+  "totalAmount",
+  "currency",
+  "metadata"
+];
+function registerAttendeeTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "attendees_list")),
+    {
+      title: "List Attendees",
+      description: "List attendees, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ATTENDEES, listVars(args, ["eventId", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedAttendees);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged attendees_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list attendees: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "attendees_create")),
+    {
+      title: "Create Attendee",
+      description: "Register an attendee record for an event. `eventId`, `fullName`, `email` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        fullName: z.string().min(1).describe("Attendee full name"),
+        email: z.string().min(1).describe("Attendee email"),
+        phone: z.string().optional().describe("Contact phone"),
+        company: z.string().optional().describe("Company/organization"),
+        role: z.string().optional().describe("Role/job title"),
+        tags: z.array(z.string()).optional().describe("Attendee tags"),
+        profile: JsonObject.optional().describe("Extended profile JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, ATTENDEE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_ATTENDEE, { input });
+        return jsonResult(data.eventfullyManagedCreateAttendee);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged attendees_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create attendee: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "attendees_update")),
+    {
+      title: "Update Attendee",
+      description: "Update an attendee. `eventId`, `fullName`, `email` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Attendee ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        fullName: z.string().min(1).describe("Attendee full name"),
+        email: z.string().min(1).describe("Attendee email"),
+        phone: z.string().optional().describe("Contact phone"),
+        company: z.string().optional().describe("Company/organization"),
+        role: z.string().optional().describe("Role/job title"),
+        tags: z.array(z.string()).optional().describe("Attendee tags"),
+        profile: JsonObject.optional().describe("Extended profile JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, ATTENDEE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_ATTENDEE, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateAttendee);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged attendees_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update attendee: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "registrations_list")),
+    {
+      title: "List Registrations",
+      description: "List ticket registrations, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REGISTRATIONS, listVars(args, ["eventId", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedRegistrations);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged registrations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list registrations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "registrations_create")),
+    {
+      title: "Create Registration",
+      description: "Create a registration tying an attendee to an event/ticket type. Only `eventId` is required; `totalAmount` is a decimal string.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeId: z.string().optional().describe("Attendee ID"),
+        ticketTypeId: z.string().optional().describe("Ticket type ID"),
+        status: z.string().optional().describe('Status, e.g. "pending", "confirmed", "cancelled"'),
+        quantity: z.number().int().optional().describe("Number of tickets"),
+        totalAmount: z.string().optional().describe("Total amount as a decimal string"),
+        currency: z.string().optional().describe('ISO currency code, e.g. "INR", "USD"'),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, REGISTRATION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_REGISTRATION, { input });
+        return jsonResult(data.eventfullyManagedCreateRegistration);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged registrations_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create registration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "registrations_update")),
+    {
+      title: "Update Registration",
+      description: "Update a registration. `eventId` is required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Registration ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeId: z.string().optional().describe("Attendee ID"),
+        ticketTypeId: z.string().optional().describe("Ticket type ID"),
+        status: z.string().optional().describe("Status"),
+        quantity: z.number().int().optional().describe("Number of tickets"),
+        totalAmount: z.string().optional().describe("Total amount as a decimal string"),
+        currency: z.string().optional().describe("ISO currency code"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, REGISTRATION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_REGISTRATION, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateRegistration);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged registrations_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update registration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var TICKET_TYPE_INPUT_KEYS = [
+  "eventId",
+  "name",
+  "description",
+  "price",
+  "currency",
+  "capacity",
+  "isActive",
+  "salesStartAt",
+  "salesEndAt",
+  "metadata"
+];
+var PROMO_CODE_INPUT_KEYS = [
+  "eventId",
+  "code",
+  "description",
+  "discountType",
+  "discountValue",
+  "maxUses",
+  "isActive",
+  "startsAt",
+  "endsAt",
+  "metadata"
+];
+function registerTicketingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tickets_list")),
+    {
+      title: "List Ticket Types",
+      description: "List ticket types, optionally filtered by event and free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        search: z.string().optional().describe("Free-text search across ticket name"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_TICKET_TYPES,
+          listVars(args, ["eventId", "search", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedTicketTypes);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged tickets_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list ticket types: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tickets_create")),
+    {
+      title: "Create Ticket Type",
+      description: 'Create a ticket type for an event. `eventId`, `name`, `price` are required; `price` is a decimal string (e.g. "499.00").',
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Ticket type name"),
+        price: z.string().min(1).describe('Price as a decimal string, e.g. "499.00"'),
+        description: z.string().optional().describe("Ticket description"),
+        currency: z.string().optional().describe('ISO currency code, e.g. "INR"'),
+        capacity: z.number().int().optional().describe("Number available"),
+        isActive: z.boolean().optional().describe("Whether the ticket is on sale"),
+        salesStartAt: z.string().optional().describe("Sales-start timestamp (ISO-8601)"),
+        salesEndAt: z.string().optional().describe("Sales-end timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, TICKET_TYPE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_TICKET_TYPE, { input });
+        return jsonResult(data.eventfullyManagedCreateTicketType);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged tickets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create ticket type: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tickets_update")),
+    {
+      title: "Update Ticket Type",
+      description: "Update a ticket type. `eventId`, `name`, `price` are required by the backend input. Use `isActive` to open/close sales.",
+      inputSchema: {
+        id: z.string().describe("Ticket type ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Ticket type name"),
+        price: z.string().min(1).describe("Price as a decimal string"),
+        description: z.string().optional().describe("Ticket description"),
+        currency: z.string().optional().describe("ISO currency code"),
+        capacity: z.number().int().optional().describe("Number available"),
+        isActive: z.boolean().optional().describe("Whether the ticket is on sale"),
+        salesStartAt: z.string().optional().describe("Sales-start timestamp (ISO-8601)"),
+        salesEndAt: z.string().optional().describe("Sales-end timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, TICKET_TYPE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_TICKET_TYPE, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateTicketType);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged tickets_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update ticket type: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tickets_delete")),
+    {
+      title: "Delete Ticket Type",
+      description: "Delete a ticket type by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Ticket type ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_TICKET_TYPE, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteTicketType, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged tickets_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete ticket type: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "promo_codes_list")),
+    {
+      title: "List Promo Codes",
+      description: "List promo codes, optionally filtered by event and free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        search: z.string().optional().describe("Free-text search across code"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PROMO_CODES,
+          listVars(args, ["eventId", "search", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedPromoCodes);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged promo_codes_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list promo codes: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "promo_codes_create")),
+    {
+      title: "Create Promo Code",
+      description: 'Create a promo code. `eventId`, `code`, `discountType`, `discountValue` are required. `discountType` is e.g. "percentage"/"fixed"; `discountValue` is a decimal string.',
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        code: z.string().min(1).describe("Promo code string (unique per event)"),
+        discountType: z.string().min(1).describe('Discount type, e.g. "percentage", "fixed"'),
+        discountValue: z.string().min(1).describe("Discount value as a decimal string"),
+        description: z.string().optional().describe("Promo description"),
+        maxUses: z.number().int().optional().describe("Maximum redemptions"),
+        isActive: z.boolean().optional().describe("Whether the code is active"),
+        startsAt: z.string().optional().describe("Valid-from timestamp (ISO-8601)"),
+        endsAt: z.string().optional().describe("Valid-until timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, PROMO_CODE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_PROMO_CODE, { input });
+        return jsonResult(data.eventfullyManagedCreatePromoCode);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged promo_codes_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create promo code: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "promo_codes_update")),
+    {
+      title: "Update Promo Code",
+      description: "Update a promo code. `eventId`, `code`, `discountType`, `discountValue` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Promo code ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        code: z.string().min(1).describe("Promo code string"),
+        discountType: z.string().min(1).describe("Discount type"),
+        discountValue: z.string().min(1).describe("Discount value as a decimal string"),
+        description: z.string().optional().describe("Promo description"),
+        maxUses: z.number().int().optional().describe("Maximum redemptions"),
+        isActive: z.boolean().optional().describe("Whether the code is active"),
+        startsAt: z.string().optional().describe("Valid-from timestamp (ISO-8601)"),
+        endsAt: z.string().optional().describe("Valid-until timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, PROMO_CODE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_PROMO_CODE, { id, input });
+        return jsonResult(data.eventfullyManagedUpdatePromoCode);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged promo_codes_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update promo code: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "promo_codes_delete")),
+    {
+      title: "Delete Promo Code",
+      description: "Delete a promo code by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Promo code ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_PROMO_CODE, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeletePromoCode, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged promo_codes_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete promo code: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var SPONSOR_INPUT_KEYS = [
+  "eventId",
+  "name",
+  "level",
+  "logoUrl",
+  "website",
+  "contactName",
+  "contactEmail",
+  "contactPhone",
+  "metrics",
+  "metadata"
+];
+var EXHIBITOR_INPUT_KEYS = [
+  "eventId",
+  "name",
+  "category",
+  "boothCode",
+  "contactName",
+  "contactEmail",
+  "status",
+  "metadata"
+];
+var LEAD_INPUT_KEYS = [
+  "eventId",
+  "attendeeName",
+  "attendeeEmail",
+  "exhibitorId",
+  "sponsorId",
+  "score",
+  "status",
+  "notes",
+  "capturedAt",
+  "metadata"
+];
+function registerSponsorshipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sponsors_list")),
+    {
+      title: "List Sponsors",
+      description: "List sponsors, optionally filtered by event and free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        search: z.string().optional().describe("Free-text search across sponsor name"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_SPONSORS,
+          listVars(args, ["eventId", "search", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedSponsors);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sponsors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sponsors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sponsors_get")),
+    {
+      title: "Get Sponsor",
+      description: "Fetch a single sponsor by ID.",
+      inputSchema: { id: z.string().describe("Sponsor ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SPONSOR, { id });
+        if (!data.eventfullyManagedSponsor) return errorResult(`Sponsor ${id} not found`);
+        return jsonResult(data.eventfullyManagedSponsor);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sponsors_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get sponsor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sponsors_create")),
+    {
+      title: "Create Sponsor",
+      description: 'Create a sponsor for an event. `eventId`, `name`, `level` are required (`level` is e.g. "platinum"/"gold"/"silver").',
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Sponsor name"),
+        level: z.string().min(1).describe('Sponsorship level, e.g. "platinum", "gold"'),
+        logoUrl: z.string().optional().describe("Logo image URL"),
+        website: z.string().optional().describe("Sponsor website"),
+        contactName: z.string().optional().describe("Primary contact name"),
+        contactEmail: z.string().optional().describe("Primary contact email"),
+        contactPhone: z.string().optional().describe("Primary contact phone"),
+        metrics: JsonObject.optional().describe("Sponsorship metrics JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, SPONSOR_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_SPONSOR, { input });
+        return jsonResult(data.eventfullyManagedCreateSponsor);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sponsors_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create sponsor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sponsors_update")),
+    {
+      title: "Update Sponsor",
+      description: "Update a sponsor. `eventId`, `name`, `level` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Sponsor ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Sponsor name"),
+        level: z.string().min(1).describe("Sponsorship level"),
+        logoUrl: z.string().optional().describe("Logo image URL"),
+        website: z.string().optional().describe("Sponsor website"),
+        contactName: z.string().optional().describe("Primary contact name"),
+        contactEmail: z.string().optional().describe("Primary contact email"),
+        contactPhone: z.string().optional().describe("Primary contact phone"),
+        metrics: JsonObject.optional().describe("Sponsorship metrics JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, SPONSOR_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_SPONSOR, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateSponsor);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sponsors_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update sponsor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sponsors_delete")),
+    {
+      title: "Delete Sponsor",
+      description: "Delete a sponsor by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Sponsor ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_SPONSOR,
+          { id }
+        );
+        return jsonResult({ deleted: data.eventfullyManagedDeleteSponsor, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged sponsors_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete sponsor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "exhibitors_list")),
+    {
+      title: "List Exhibitors",
+      description: "List exhibitors, optionally filtered by event and free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        search: z.string().optional().describe("Free-text search across exhibitor name"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_EXHIBITORS,
+          listVars(args, ["eventId", "search", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedExhibitors);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged exhibitors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list exhibitors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "exhibitors_create")),
+    {
+      title: "Create Exhibitor",
+      description: "Create an exhibitor for an event. `eventId`, `name` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Exhibitor name"),
+        category: z.string().optional().describe("Exhibitor category"),
+        boothCode: z.string().optional().describe("Assigned booth code"),
+        contactName: z.string().optional().describe("Primary contact name"),
+        contactEmail: z.string().optional().describe("Primary contact email"),
+        status: z.string().optional().describe('Status, e.g. "confirmed", "pending"'),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, EXHIBITOR_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_EXHIBITOR, { input });
+        return jsonResult(data.eventfullyManagedCreateExhibitor);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged exhibitors_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create exhibitor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "exhibitors_update")),
+    {
+      title: "Update Exhibitor",
+      description: "Update an exhibitor. `eventId`, `name` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Exhibitor ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Exhibitor name"),
+        category: z.string().optional().describe("Exhibitor category"),
+        boothCode: z.string().optional().describe("Assigned booth code"),
+        contactName: z.string().optional().describe("Primary contact name"),
+        contactEmail: z.string().optional().describe("Primary contact email"),
+        status: z.string().optional().describe("Status"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, EXHIBITOR_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_EXHIBITOR, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateExhibitor);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged exhibitors_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update exhibitor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "exhibitors_delete")),
+    {
+      title: "Delete Exhibitor",
+      description: "Delete an exhibitor by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Exhibitor ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_EXHIBITOR, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteExhibitor, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged exhibitors_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete exhibitor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "leads_list")),
+    {
+      title: "List Leads",
+      description: "List captured leads (booth/sponsor lead-capture), optionally filtered by event and free-text search, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        search: z.string().optional().describe("Free-text search across lead name/email"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LEADS, listVars(args, ["eventId", "search", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedLeads);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged leads_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list leads: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "leads_create")),
+    {
+      title: "Create Lead",
+      description: "Capture a lead at an event (tied to an exhibitor or sponsor). `eventId`, `attendeeName`, `attendeeEmail` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeName: z.string().min(1).describe("Lead/attendee name"),
+        attendeeEmail: z.string().min(1).describe("Lead/attendee email"),
+        exhibitorId: z.string().optional().describe("Capturing exhibitor ID"),
+        sponsorId: z.string().optional().describe("Capturing sponsor ID"),
+        score: z.number().int().optional().describe("Lead score"),
+        status: z.string().optional().describe('Status, e.g. "new", "qualified", "contacted"'),
+        notes: z.string().optional().describe("Free-text notes"),
+        capturedAt: z.string().optional().describe("Capture timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, LEAD_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_LEAD, { input });
+        return jsonResult(data.eventfullyManagedCreateLead);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged leads_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create lead: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "leads_update")),
+    {
+      title: "Update Lead",
+      description: "Update a lead. `eventId`, `attendeeName`, `attendeeEmail` are required by the backend input. Use `status`/`score` to progress the lead.",
+      inputSchema: {
+        id: z.string().describe("Lead ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeName: z.string().min(1).describe("Lead/attendee name"),
+        attendeeEmail: z.string().min(1).describe("Lead/attendee email"),
+        exhibitorId: z.string().optional().describe("Capturing exhibitor ID"),
+        sponsorId: z.string().optional().describe("Capturing sponsor ID"),
+        score: z.number().int().optional().describe("Lead score"),
+        status: z.string().optional().describe("Status"),
+        notes: z.string().optional().describe("Free-text notes"),
+        capturedAt: z.string().optional().describe("Capture timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, LEAD_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_LEAD, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateLead);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged leads_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update lead: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "leads_delete")),
+    {
+      title: "Delete Lead",
+      description: "Delete a lead by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Lead ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_LEAD,
+          { id }
+        );
+        return jsonResult({ deleted: data.eventfullyManagedDeleteLead, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged leads_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete lead: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var STATION_INPUT_KEYS = [
+  "eventId",
+  "name",
+  "code",
+  "location",
+  "isActive",
+  "kioskConfig",
+  "metadata"
+];
+var RECORD_INPUT_KEYS = [
+  "eventId",
+  "registrationId",
+  "attendeeId",
+  "stationId",
+  "direction",
+  "method",
+  "status",
+  "recordedAt",
+  "metadata"
+];
+function registerCheckinTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_stations_list")),
+    {
+      title: "List Check-in Stations",
+      description: "List check-in stations/kiosks, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_CHECK_IN_STATIONS,
+          listVars(args, ["eventId", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedCheckInStations);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_stations_list failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list check-in stations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_stations_create")),
+    {
+      title: "Create Check-in Station",
+      description: "Create a check-in station/kiosk. `eventId`, `name`, `code` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Station name"),
+        code: z.string().min(1).describe("Station code (unique per event)"),
+        location: z.string().optional().describe("Physical location/description"),
+        isActive: z.boolean().optional().describe("Whether the station is active"),
+        kioskConfig: JsonObject.optional().describe("Kiosk configuration JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, STATION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_CHECK_IN_STATION, { input });
+        return jsonResult(data.eventfullyManagedCreateCheckInStation);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_stations_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create check-in station: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_stations_update")),
+    {
+      title: "Update Check-in Station",
+      description: "Update a check-in station. `eventId`, `name`, `code` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Check-in station ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        name: z.string().min(1).describe("Station name"),
+        code: z.string().min(1).describe("Station code"),
+        location: z.string().optional().describe("Physical location/description"),
+        isActive: z.boolean().optional().describe("Whether the station is active"),
+        kioskConfig: JsonObject.optional().describe("Kiosk configuration JSON"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, STATION_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_CHECK_IN_STATION, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateCheckInStation);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_stations_update failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to update check-in station: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_stations_delete")),
+    {
+      title: "Delete Check-in Station",
+      description: "Delete a check-in station by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Check-in station ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_CHECK_IN_STATION, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteCheckInStation, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_stations_delete failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to delete check-in station: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_records_list")),
+    {
+      title: "List Check-in Records",
+      description: "List check-in/check-out records, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_CHECK_IN_RECORDS,
+          listVars(args, ["eventId", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedCheckInRecords);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_records_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list check-in records: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_records_create")),
+    {
+      title: "Create Check-in Record",
+      description: 'Record a check-in/check-out scan. `eventId` is required; `direction` is e.g. "in"/"out", `method` is e.g. "qr"/"manual".',
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        registrationId: z.string().optional().describe("Related registration ID"),
+        attendeeId: z.string().optional().describe("Attendee ID"),
+        stationId: z.string().optional().describe("Capturing station ID"),
+        direction: z.string().optional().describe('Direction, e.g. "in", "out"'),
+        method: z.string().optional().describe('Method, e.g. "qr", "nfc", "manual"'),
+        status: z.string().optional().describe('Status, e.g. "success", "denied"'),
+        recordedAt: z.string().optional().describe("Recorded timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, RECORD_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_CHECK_IN_RECORD, { input });
+        return jsonResult(data.eventfullyManagedCreateCheckInRecord);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_records_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create check-in record: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_records_update")),
+    {
+      title: "Update Check-in Record",
+      description: "Update a check-in record. `eventId` is required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Check-in record ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        registrationId: z.string().optional().describe("Related registration ID"),
+        attendeeId: z.string().optional().describe("Attendee ID"),
+        stationId: z.string().optional().describe("Capturing station ID"),
+        direction: z.string().optional().describe('Direction, e.g. "in", "out"'),
+        method: z.string().optional().describe('Method, e.g. "qr", "nfc", "manual"'),
+        status: z.string().optional().describe("Status"),
+        recordedAt: z.string().optional().describe("Recorded timestamp (ISO-8601)"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, RECORD_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_CHECK_IN_RECORD, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateCheckInRecord);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_records_update failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to update check-in record: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "checkin_records_delete")),
+    {
+      title: "Delete Check-in Record",
+      description: "Delete a check-in record by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Check-in record ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_CHECK_IN_RECORD, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteCheckInRecord, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged checkin_records_delete failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to delete check-in record: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var PROFILE_INPUT_KEYS = [
+  "eventId",
+  "attendeeId",
+  "industry",
+  "role",
+  "interests",
+  "lookingFor",
+  "visibility",
+  "metadata"
+];
+var MATCH_INPUT_KEYS = [
+  "eventId",
+  "sourceProfileId",
+  "targetProfileId",
+  "score",
+  "reason",
+  "status",
+  "metadata"
+];
+var MEETING_INPUT_KEYS = [
+  "eventId",
+  "title",
+  "sourceProfileId",
+  "targetProfileId",
+  "status",
+  "location",
+  "notes",
+  "startsAt",
+  "endsAt",
+  "metadata"
+];
+function registerNetworkingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_list")),
+    {
+      title: "List Networking Profiles",
+      description: "List networking profiles, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_NETWORKING_PROFILES,
+          listVars(args, ["eventId", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedNetworkingProfiles);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged profiles_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list networking profiles: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_create")),
+    {
+      title: "Create Networking Profile",
+      description: "Create a networking profile for an attendee. `eventId`, `attendeeId` are required. `interests`/`lookingFor` are string arrays.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeId: z.string().min(1).describe("Attendee ID this profile belongs to"),
+        industry: z.string().optional().describe("Industry"),
+        role: z.string().optional().describe("Professional role"),
+        interests: z.array(z.string()).optional().describe("Topics of interest"),
+        lookingFor: z.array(z.string()).optional().describe("What the attendee is looking for"),
+        visibility: z.string().optional().describe('Visibility, e.g. "public", "private"'),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, PROFILE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_NETWORKING_PROFILE, { input });
+        return jsonResult(data.eventfullyManagedCreateNetworkingProfile);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged profiles_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create networking profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_update")),
+    {
+      title: "Update Networking Profile",
+      description: "Update a networking profile. `eventId`, `attendeeId` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Networking profile ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        attendeeId: z.string().min(1).describe("Attendee ID this profile belongs to"),
+        industry: z.string().optional().describe("Industry"),
+        role: z.string().optional().describe("Professional role"),
+        interests: z.array(z.string()).optional().describe("Topics of interest"),
+        lookingFor: z.array(z.string()).optional().describe("What the attendee is looking for"),
+        visibility: z.string().optional().describe("Visibility"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, PROFILE_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_NETWORKING_PROFILE, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateNetworkingProfile);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged profiles_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update networking profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profiles_delete")),
+    {
+      title: "Delete Networking Profile",
+      description: "Delete a networking profile by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Networking profile ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_NETWORKING_PROFILE, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteNetworkingProfile, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged profiles_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete networking profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "matches_list")),
+    {
+      title: "List Networking Matches",
+      description: "List suggested networking matches, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_NETWORKING_MATCHES,
+          listVars(args, ["eventId", "workspaceId", "limit", "offset"])
+        );
+        return jsonResult(data.eventfullyManagedNetworkingMatches);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged matches_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list networking matches: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "matches_create")),
+    {
+      title: "Create Networking Match",
+      description: "Create a networking match between two profiles. `eventId`, `sourceProfileId`, `targetProfileId`, `score` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        sourceProfileId: z.string().min(1).describe("Source networking profile ID"),
+        targetProfileId: z.string().min(1).describe("Target networking profile ID"),
+        score: z.number().int().describe("Match score"),
+        reason: z.string().optional().describe("Why the match was suggested"),
+        status: z.string().optional().describe('Status, e.g. "suggested", "accepted", "declined"'),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, MATCH_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_NETWORKING_MATCH, { input });
+        return jsonResult(data.eventfullyManagedCreateNetworkingMatch);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged matches_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create networking match: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "matches_update")),
+    {
+      title: "Update Networking Match",
+      description: "Update a networking match. `eventId`, `sourceProfileId`, `targetProfileId`, `score` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Networking match ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        sourceProfileId: z.string().min(1).describe("Source networking profile ID"),
+        targetProfileId: z.string().min(1).describe("Target networking profile ID"),
+        score: z.number().int().describe("Match score"),
+        reason: z.string().optional().describe("Why the match was suggested"),
+        status: z.string().optional().describe("Status"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, MATCH_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_NETWORKING_MATCH, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateNetworkingMatch);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged matches_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update networking match: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "matches_delete")),
+    {
+      title: "Delete Networking Match",
+      description: "Delete a networking match by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Networking match ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_NETWORKING_MATCH, { id });
+        return jsonResult({ deleted: data.eventfullyManagedDeleteNetworkingMatch, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged matches_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete networking match: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meetings_list")),
+    {
+      title: "List Meetings",
+      description: "List scheduled 1:1 networking meetings, optionally filtered by event, with pagination. Returns items + total.",
+      inputSchema: {
+        eventId: z.string().optional().describe("Filter by event ID"),
+        ...PaginationShape
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEETINGS, listVars(args, ["eventId", "workspaceId", "limit", "offset"]));
+        return jsonResult(data.eventfullyManagedMeetings);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged meetings_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list meetings: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meetings_create")),
+    {
+      title: "Create Meeting",
+      description: "Schedule a 1:1 networking meeting. `eventId`, `title`, `startsAt`, `endsAt` are required.",
+      inputSchema: {
+        eventId: z.string().min(1).describe("Owning event ID"),
+        title: z.string().min(1).describe("Meeting title"),
+        startsAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endsAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        sourceProfileId: z.string().optional().describe("Requesting profile ID"),
+        targetProfileId: z.string().optional().describe("Invited profile ID"),
+        status: z.string().optional().describe('Status, e.g. "requested", "confirmed", "declined"'),
+        location: z.string().optional().describe("Meeting location"),
+        notes: z.string().optional().describe("Free-text notes"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async (args) => {
+      try {
+        const input = buildInput(args, MEETING_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(CREATE_MEETING, { input });
+        return jsonResult(data.eventfullyManagedCreateMeeting);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged meetings_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create meeting: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meetings_update")),
+    {
+      title: "Update Meeting",
+      description: "Update a networking meeting. `eventId`, `title`, `startsAt`, `endsAt` are required by the backend input.",
+      inputSchema: {
+        id: z.string().describe("Meeting ID"),
+        eventId: z.string().min(1).describe("Owning event ID"),
+        title: z.string().min(1).describe("Meeting title"),
+        startsAt: z.string().min(1).describe("Start timestamp (ISO-8601 DateTime)"),
+        endsAt: z.string().min(1).describe("End timestamp (ISO-8601 DateTime)"),
+        sourceProfileId: z.string().optional().describe("Requesting profile ID"),
+        targetProfileId: z.string().optional().describe("Invited profile ID"),
+        status: z.string().optional().describe("Status"),
+        location: z.string().optional().describe("Meeting location"),
+        notes: z.string().optional().describe("Free-text notes"),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = buildInput(rest, MEETING_INPUT_KEYS);
+        const data = await ctx.gql.workspace.request(UPDATE_MEETING, { id, input });
+        return jsonResult(data.eventfullyManagedUpdateMeeting);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged meetings_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update meeting: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meetings_delete")),
+    {
+      title: "Delete Meeting",
+      description: "Delete a networking meeting by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Meeting ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_MEETING,
+          { id }
+        );
+        return jsonResult({ deleted: data.eventfullyManagedDeleteMeeting, id });
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged meetings_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete meeting: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var SIMPLE_ENTITY_INPUT_KEYS = ["name", "title", "status", "eventId", "metadata"];
+var SURFACES = [
+  {
+    listSuffix: "announcements_list",
+    upsertSuffix: "announcements_upsert",
+    label: "announcements",
+    listRoot: "eventfullyManagedAnnouncements",
+    upsertRoot: "eventfullyManagedUpsertAnnouncement",
+    listOp: LIST_ANNOUNCEMENTS,
+    upsertOp: UPSERT_ANNOUNCEMENT
+  },
+  {
+    listSuffix: "automation_rules_list",
+    upsertSuffix: "automation_rules_upsert",
+    label: "automation rules",
+    listRoot: "eventfullyManagedAutomationRules",
+    upsertRoot: "eventfullyManagedUpsertAutomationRule",
+    listOp: LIST_AUTOMATION_RULES,
+    upsertOp: UPSERT_AUTOMATION_RULE
+  },
+  {
+    listSuffix: "communication_campaigns_list",
+    upsertSuffix: "communication_campaigns_upsert",
+    label: "communication campaigns",
+    listRoot: "eventfullyManagedCommunicationCampaigns",
+    upsertRoot: "eventfullyManagedUpsertCommunicationCampaign",
+    listOp: LIST_COMMUNICATION_CAMPAIGNS,
+    upsertOp: UPSERT_COMMUNICATION_CAMPAIGN
+  },
+  {
+    listSuffix: "workflow_templates_list",
+    upsertSuffix: "workflow_templates_upsert",
+    label: "workflow templates",
+    listRoot: "eventfullyManagedWorkflowTemplates",
+    upsertRoot: "eventfullyManagedUpsertWorkflowTemplate",
+    listOp: LIST_WORKFLOW_TEMPLATES,
+    upsertOp: UPSERT_WORKFLOW_TEMPLATE
+  },
+  {
+    listSuffix: "analytics_snapshots_list",
+    upsertSuffix: "analytics_snapshots_upsert",
+    label: "analytics snapshots",
+    listRoot: "eventfullyManagedAnalyticsSnapshots",
+    upsertRoot: "eventfullyManagedUpsertAnalyticsSnapshot",
+    listOp: LIST_ANALYTICS_SNAPSHOTS,
+    upsertOp: UPSERT_ANALYTICS_SNAPSHOT
+  }
+];
+function registerContentTools(server, ctx, track) {
+  for (const s of SURFACES) {
+    server.registerTool(
+      track(mcpToolName(ctx.productName, s.listSuffix)),
+      {
+        title: `List ${s.label}`,
+        description: `List ${s.label}, optionally filtered by event, with pagination. Returns items + total.`,
+        inputSchema: {
+          eventId: z.string().optional().describe("Filter by event ID"),
+          ...PaginationShape
+        }
+      },
+      async (args) => {
+        try {
+          const data = await ctx.gql.workspace.request(
+            s.listOp,
+            listVars(args, ["eventId", "workspaceId", "limit", "offset"])
+          );
+          return jsonResult(data[s.listRoot]);
+        } catch (error) {
+          ctx.logger.error(`eventfullymanaged ${s.listSuffix} failed`, { error: String(error) });
+          return errorResult(
+            `Failed to list ${s.label}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.registerTool(
+      track(mcpToolName(ctx.productName, s.upsertSuffix)),
+      {
+        title: `Upsert ${s.label.replace(/s$/, "")}`,
+        description: `Create or update a ${s.label.replace(/s$/, "")} record. Omit \`id\` to create; pass \`id\` to update. All content fields are optional.`,
+        inputSchema: {
+          id: z.string().optional().describe("Record ID \u2014 omit to create, pass to update"),
+          name: z.string().optional().describe("Record name"),
+          title: z.string().optional().describe("Record title"),
+          status: z.string().optional().describe("Record status"),
+          eventId: z.string().optional().describe("Associated event ID"),
+          metadata: JsonObject.optional().describe(
+            "Arbitrary payload JSON (the real config lives here)"
+          )
+        }
+      },
+      async ({ id, ...rest }) => {
+        try {
+          const input = buildInput(rest, SIMPLE_ENTITY_INPUT_KEYS);
+          const vars = { input };
+          if (id !== void 0) vars.id = id;
+          const data = await ctx.gql.workspace.request(s.upsertOp, vars);
+          return jsonResult(data[s.upsertRoot]);
+        } catch (error) {
+          ctx.logger.error(`eventfullymanaged ${s.upsertSuffix} failed`, { error: String(error) });
+          return errorResult(
+            `Failed to upsert ${s.label.replace(/s$/, "")}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+  }
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "dashboard_summary")),
+    {
+      title: "Dashboard Summary",
+      description: "Headline event-management KPIs: total/active events, venues, registrations, attendees, sponsors, upcoming sessions, and the latest events.",
+      inputSchema: {
+        workspaceId: z.string().optional().describe("Optional workspace ID (defaults to the gateway-bound workspace)")
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(DASHBOARD_SUMMARY, listVars(args, ["workspaceId"]));
+        return jsonResult(data.eventfullyManagedDashboardSummary);
+      } catch (error) {
+        ctx.logger.error("eventfullymanaged dashboard_summary failed", { error: String(error) });
+        return errorResult(
+          `Failed to get dashboard summary: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/eventfullymanaged/resources.ts
+function registerEventfullymanagedResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const dashboardUri = track(mcpResourceUri(ctx.productName, "dashboard"));
+  const eventsUri = track(mcpResourceUri(ctx.productName, "events"));
+  const venuesUri = track(mcpResourceUri(ctx.productName, "venues"));
+  server.registerResource(
+    "eventfullymanaged-schema",
+    schemaUri,
+    {
+      title: "Eventfullymanaged Domain Schema",
+      description: "Overview of the Eventfullymanaged event-management domain \u2014 entities, free-form status conventions, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Eventfullymanaged Domain (Overview)
+
+End-to-end event-management platform: plan events, sell tickets, run check-in,
+power networking, and operate the show.
+
+## Entities
+- EventfullyManagedEvent \u2014 the top-level event
+- EventfullyManagedVenue (+ EventfullyManagedFloorPlan) \u2014 physical venues + floor plans
+- EventfullyManagedEventSession \u2014 agenda/program sessions
+- EventfullyManagedSpeaker \u2014 speaker profiles
+- EventfullyManagedAttendee \u2014 attendee records
+- EventfullyManagedRegistration \u2014 ticket registrations
+- EventfullyManagedTicketType \u2014 ticket types (price as decimal string)
+- EventfullyManagedPromoCode \u2014 discount codes
+- EventfullyManagedSponsor \u2014 event sponsors
+- EventfullyManagedExhibitor \u2014 expo exhibitors
+- EventfullyManagedLead \u2014 captured booth/sponsor leads
+- EventfullyManagedCheckInStation / EventfullyManagedCheckInRecord \u2014 check-in kiosks + scans
+- EventfullyManagedNetworkingProfile / NetworkingMatch / Meeting \u2014 attendee networking
+- "Simple entity" surfaces (upsertable): announcements, automation rules,
+  communication campaigns, workflow templates, analytics snapshots
+
+## Conventions
+- status / type / visibility / level / direction / method / discountType are
+  FREE-FORM strings (no GraphQL enums) \u2014 use the values your event app expects.
+- Monetary fields (ticket price, promo discountValue, registration totalAmount)
+  are DECIMAL STRINGS, not numbers.
+- The create and update mutations share one input type per entity, so update
+  requires the same required fields as create (plus the id).
+- All operations run against the WORKSPACE gateway and are workspace-scoped via
+  gateway headers; list queries also accept an OPTIONAL workspaceId filter.
+
+## Tool groups
+events; venues + floor_plans; sessions + speakers (agenda); attendees +
+registrations; tickets + promo_codes; sponsors + exhibitors + leads; checkin
+(stations + records); networking (profiles + matches + meetings); content
+(announcements / automation_rules / communication_campaigns / workflow_templates
+/ analytics_snapshots) + dashboard_summary.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "eventfullymanaged-dashboard",
+    dashboardUri,
+    {
+      title: "Eventfullymanaged Dashboard Summary",
+      description: "Live headline KPIs (events, venues, registrations, attendees, sponsors, upcoming sessions, latest events).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${dashboardUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(DASHBOARD_SUMMARY, {});
+        return {
+          contents: [
+            {
+              uri: dashboardUri,
+              text: JSON.stringify(data.eventfullyManagedDashboardSummary, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: dashboardUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "eventfullymanaged-events",
+    eventsUri,
+    {
+      title: "Eventfullymanaged Event Directory",
+      description: "The first 50 events in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${eventsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_EVENTS,
+          { limit: 50, offset: 0 }
+        );
+        return {
+          contents: [
+            {
+              uri: eventsUri,
+              text: JSON.stringify(data.eventfullyManagedEvents, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: eventsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "eventfullymanaged-venues",
+    venuesUri,
+    {
+      title: "Eventfullymanaged Venue Directory",
+      description: "The first 50 venues in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${venuesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_VENUES,
+          { limit: 50, offset: 0 }
+        );
+        return {
+          contents: [
+            {
+              uri: venuesUri,
+              text: JSON.stringify(data.eventfullyManagedVenues, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: venuesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerEventfullymanagedPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const setupName = track(mcpPromptName(p, "event-setup"));
+  const opsName = track(mcpPromptName(p, "event-ops"));
+  server.registerPrompt(
+    setupName,
+    {
+      title: "Event Setup",
+      description: "Guide for standing up a new event end to end: create the event, pick/create a venue, build the agenda, define ticket types, and open registration.",
+      argsSchema: {
+        name: z.string().optional().describe("Event name"),
+        type: z.string().optional().describe("Event type (conference, workshop, webinar, ...)")
+      }
+    },
+    ({ name, type }) => {
+      ctx.logger.debug(`Prompt ${setupName} called`, { name, type });
+      const nameNote = name ? `Use the event name "${name}".` : "Ask the user for the event name.";
+      const typeNote = type ? `Use type ${type}.` : "Help the user pick an event type.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a new Eventfullymanaged event.
+
+1. **Create Event**: Use ${p}_events_create. ${nameNote} ${typeNote} Provide a timezone (IANA, e.g. "Asia/Kolkata") and startAt/endAt ISO-8601 timestamps.
+2. **Venue**: Use ${p}_venues_list to reuse an existing venue, or ${p}_venues_create for a new one. Optionally add a layout with ${p}_floor_plans_create.
+3. **Agenda**: Add program sessions with ${p}_sessions_create (eventId, title, sessionType, startsAt/endsAt) and speakers with ${p}_speakers_create.
+4. **Tickets**: Define ticket types with ${p}_tickets_create (price is a decimal string). Optionally add discounts with ${p}_promo_codes_create.
+5. **Sponsors / Exhibitors**: Use ${p}_sponsors_create and ${p}_exhibitors_create as needed.
+6. **Open Registration**: Confirm ticket types are isActive, then publish the event via ${p}_events_update with status="published".
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Event Operations",
+      description: "Live event-day operations: review KPIs, manage registrations + check-in, drive sponsor/exhibitor lead capture, and power attendee networking.",
+      argsSchema: {
+        eventId: z.string().optional().describe("Event ID to operate")
+      }
+    },
+    ({ eventId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { eventId });
+      const eventNote = eventId ? `Operate event "${eventId}".` : `First list events with ${p}_events_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run live Eventfullymanaged operations. ${eventNote}
+
+1. **KPIs**: Use ${p}_dashboard_summary for headline numbers.
+2. **Registrations**: Use ${p}_registrations_list (filter by eventId) to track sign-ups; create walk-ins with ${p}_attendees_create + ${p}_registrations_create.
+3. **Check-in**: Ensure stations are live with ${p}_checkin_stations_list; log scans with ${p}_checkin_records_create (direction "in"/"out").
+4. **Sponsors & Leads**: Capture booth leads with ${p}_leads_create and progress them with ${p}_leads_update (status/score).
+5. **Networking**: Review ${p}_matches_list and confirm 1:1s with ${p}_meetings_update.
+6. **Comms**: Push updates by upserting an announcement with ${p}_announcements_upsert.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/eventfullymanaged/index.ts
+var eventfullymanagedModule = {
+  id: "eventfullymanaged",
+  version: "0.0.1",
+  displayName: "Eventfullymanaged",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerEventTools(server, ctx, trackTool);
+    registerVenueTools(server, ctx, trackTool);
+    registerAgendaTools(server, ctx, trackTool);
+    registerAttendeeTools(server, ctx, trackTool);
+    registerTicketingTools(server, ctx, trackTool);
+    registerSponsorshipTools(server, ctx, trackTool);
+    registerCheckinTools(server, ctx, trackTool);
+    registerNetworkingTools(server, ctx, trackTool);
+    registerContentTools(server, ctx, trackTool);
+    registerEventfullymanagedResources(server, ctx, trackResource);
+    registerEventfullymanagedPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var eventfullymanaged_default = eventfullymanagedModule;
+
+export { eventfullymanaged_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map