@timardex/cluemart-shared 1.6.130 → 1.7.1

package/dist/chunk-R6PCFOYO.mjs

@@ -0,0 +1,3650 @@
+import {
+  CONTACT_DETAILS_FIELDS_FRAGMENT,
+  EVENT,
+  EVENT_INFO,
+  EVENT_LIST_ITEM,
+  GET_EVENT,
+  GET_EVENTS,
+  GET_EVENTS_BY_REGION,
+  GET_EVENTS_NEAR_ME,
+  GET_EVENT_BY_PLACE_ID,
+  GET_EVENT_INFO,
+  GET_PARTNER,
+  GET_PARTNERS,
+  GET_PARTNERS_BY_REGION,
+  GET_UNREGISTERED_VENDOR,
+  GET_UNREGISTERED_VENDORS,
+  GET_UNREGISTERED_VENDORS_BY_INVITER_ID,
+  GET_USER,
+  GET_USER_ACTIVITIES,
+  GET_USER_EVENTS,
+  GET_USER_PARTNERS,
+  GET_USER_VENDORS,
+  GET_VENDOR,
+  GET_VENDORS,
+  GET_VENDORS_BY_REGION,
+  GET_VENDOR_INFO,
+  LICENCE_FIELDS_FRAGMENT,
+  LOCATION_FIELDS_FRAGMENT,
+  LOCATION_GEO_FIELDS_FRAGMENT,
+  OWNER_FIELDS_FRAGMENT,
+  PARTNER,
+  POSTER_USAGE_FIELDS_FRAGMENT,
+  RELATION_DATES_FRAGMENT,
+  RESOURCE_IMAGE_FIELDS_FRAGMENT,
+  SEARCH_EVENTS,
+  SEARCH_PARTNERS,
+  SEARCH_VENDORS,
+  SOCIAL_MEDIA_FIELDS_FRAGMENT,
+  SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT,
+  TERMS_AGREEMENT_FIELDS_FRAGMENT,
+  UNREGISTERED_VENDOR,
+  USER_FIELDS_FRAGMENT,
+  VENDOR,
+  VENDOR_INFO
+} from "./chunk-32MKHJTX.mjs";
+
+// src/graphql/queries/post.ts
+import { gql as gql3 } from "@apollo/client";
+
+// src/graphql/queries/game/dailyClue.ts
+import { gql } from "@apollo/client";
+var GAME_DATE_FIELDS_FRAGMENT = gql`
+  fragment GameDateFields on GameDateType {
+    startDate
+    endDate
+  }
+`;
+var DAILY_CLUE_BASE_GAME_FIELDS_FRAGMENT = gql`
+  fragment DailyClueBaseGameFields on DailyClueBaseGameType {
+    gameDate {
+      ...GameDateFields
+    }
+    gameSolution
+  }
+  ${GAME_DATE_FIELDS_FRAGMENT}
+`;
+var DAILY_CLUE_GAME_DATA_FIELDS_FRAGMENT = gql`
+  fragment DailyClueGameDataFields on DailyClueGameDataType {
+    gameFields {
+      ...DailyClueBaseGameFields
+    }
+    lastFoundDate
+    points
+    letterInfo {
+      collected
+      solutionShuffled
+      todaysClue
+      todaysLetter
+      todaysPlacement
+    }
+    streak
+  }
+  ${DAILY_CLUE_BASE_GAME_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/queries/game/puzzleGame.ts
+import { gql as gql2 } from "@apollo/client";
+var PUZZLE_ANSWER_FIELDS_FRAGMENT = gql2`
+  fragment PuzzleAnswerFields on PuzzleAnswerType {
+    answer
+    answerId
+    correct
+  }
+`;
+var PUZZLE_QUESTION_FIELDS_FRAGMENT = gql2`
+  fragment PuzzleQuestionFields on PuzzleQuestionType {
+    answers {
+      ...PuzzleAnswerFields
+    }
+    question
+    questionId
+  }
+  ${PUZZLE_ANSWER_FIELDS_FRAGMENT}
+`;
+var PUZZLE_ANSWERED_QUESTION_FIELDS_FRAGMENT = gql2`
+  fragment PuzzleAnsweredQuestionFields on PuzzleAnsweredQuestionType {
+    questionId
+    selectedAnswerId
+  }
+`;
+var PUZZLE_BASE_GAME_FIELDS_FRAGMENT = gql2`
+  fragment PuzzleBaseGameFields on PuzzleBaseGameType {
+    questions {
+      ...PuzzleQuestionFields
+    }
+  }
+  ${PUZZLE_QUESTION_FIELDS_FRAGMENT}
+`;
+var PUZZLE_GAME_DATA_FIELDS_FRAGMENT = gql2`
+  fragment PuzzleGameDataFields on PuzzleGameDataType {
+    gameFields {
+      ...PuzzleBaseGameFields
+    }
+    answeredQuestions {
+      ...PuzzleAnsweredQuestionFields
+    }
+    points
+    streak
+  }
+  ${PUZZLE_BASE_GAME_FIELDS_FRAGMENT}
+  ${PUZZLE_ANSWERED_QUESTION_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/queries/post.ts
+var BASE_GAME_FIELDS_FRAGMENT = gql3`
+  fragment BaseGameFields on BaseGameType {
+    gameTypeId
+    gameTitle
+    gameType
+    dailyClue {
+      ...DailyClueBaseGameFields
+    }
+    miniQuiz {
+      ...PuzzleBaseGameFields
+    }
+    oddOneOut {
+      ...PuzzleBaseGameFields
+    }
+  }
+  ${DAILY_CLUE_BASE_GAME_FIELDS_FRAGMENT}
+  ${PUZZLE_BASE_GAME_FIELDS_FRAGMENT}
+`;
+var POST_CONTENT_DATA_FIELDS_FRAGMENT = gql3`
+  fragment PostContentDataFields on PostContentData {
+    game {
+      ...BaseGameFields
+    }
+    textarea {
+      title
+      data
+    }
+    images {
+      ...ResourceImageFields
+    }
+    video {
+      source
+      title
+    }
+    list {
+      title
+      items {
+        text
+      }
+    }
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${BASE_GAME_FIELDS_FRAGMENT}
+`;
+var POST_CONTENT_FIELDS_FRAGMENT = gql3`
+  fragment PostContentFields on PostContentType {
+    contentData {
+      ...PostContentDataFields
+    }
+    contentOrder
+    contentType
+  }
+  ${POST_CONTENT_DATA_FIELDS_FRAGMENT}
+`;
+var POST_RESOURCE_FIELDS_FRAGMENT = gql3`
+  fragment PostResourceFields on PostResourceType {
+    resourceId
+    resourceSlug
+    resourceRegion
+    resourceType
+  }
+`;
+var POST_FIELDS_FRAGMENT = gql3`
+  fragment PostFields on PostType {
+    _id
+    active
+    approvedAt
+    caption
+    content {
+      ...PostContentFields
+    }
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    deletedAt
+    postType
+    resource {
+      ...PostResourceFields
+    }
+    tags
+    title
+    slug
+    sharePublic {
+      ...SocialShareResourceFields
+    }
+    updatedAt
+  }
+  ${POST_CONTENT_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${POST_RESOURCE_FIELDS_FRAGMENT}
+  ${SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT}
+`;
+var GET_POSTS = gql3`
+  query getPosts {
+    posts {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var GET_POST = gql3`
+  query getPost($_id: ID!) {
+    post(_id: $_id) {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var GET_POSTS_BY_TYPE = gql3`
+  query getPostsByType($postType: PostTypeEnum!) {
+    postsByType(postType: $postType) {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/queries/shareSlug.ts
+import { gql as gql4 } from "@apollo/client";
+var GET_EVENT_BY_SLUG = gql4`
+  query getEventBySlug($slug: String!) {
+    eventBySlug(slug: $slug) {
+      _id
+    }
+  }
+`;
+var GET_VENDOR_BY_SLUG = gql4`
+  query getVendorBySlug($slug: String!) {
+    vendorBySlug(slug: $slug) {
+      _id
+    }
+  }
+`;
+var GET_PARTNER_BY_SLUG = gql4`
+  query getPartnerBySlug($slug: String!) {
+    partnerBySlug(slug: $slug) {
+      _id
+    }
+  }
+`;
+var GET_POST_BY_SLUG = gql4`
+  query getPostBySlug($slug: String!, $postType: PostTypeEnum!) {
+    postBySlug(slug: $slug, postType: $postType) {
+      _id
+    }
+  }
+`;
+
+// src/graphql/queries/relation.ts
+import { gql as gql5 } from "@apollo/client";
+var RELATION_FIELDS_FRAGMENT = gql5`
+  fragment RelationFields on RelationType {
+    _id
+    active
+    chatId
+    createdAt
+    lastUpdateBy
+    eventId
+    relationDates {
+      ...RelationDates
+    }
+    relationType
+    vendorId
+    updatedAt
+  }
+  ${RELATION_DATES_FRAGMENT}
+`;
+var GET_RELATION = gql5`
+  query getRelation($_id: ID!) {
+    relation(_id: $_id) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_RELATION_BY_EVENT_AND_VENDOR = gql5`
+  query getRelationByEventAndVendor($eventId: ID!, $vendorId: ID!) {
+    relationByEventAndVendor(eventId: $eventId, vendorId: $vendorId) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_EVENT_RELATIONS = gql5`
+  query getEventRelations($eventId: ID!) {
+    eventRelations(eventId: $eventId) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_VENDOR_RELATIONS = gql5`
+  query getVendorRelations($vendorId: ID!) {
+    vendorRelations(vendorId: $vendorId) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_RESOURCE_CONNECTIONS = gql5`
+  query getResourceConnections(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+  ) {
+    resourceConnections(resourceId: $resourceId, resourceType: $resourceType) {
+      events {
+        ...EventListItemFields
+      }
+      vendors {
+        ...VendorFields
+      }
+    }
+  }
+  ${VENDOR}
+  ${EVENT_LIST_ITEM}
+`;
+
+// src/graphql/toGraphqlQueryString.ts
+import { print } from "graphql";
+function toGraphqlQueryString(query) {
+  return print(query);
+}
+
+// src/graphql/hooks/admin/hooksMutation.ts
+import { useMutation } from "@apollo/client";
+
+// src/graphql/mutations/admin.ts
+import { gql as gql6 } from "@apollo/client";
+var ADMIN_UPDATE_RESOURCE_TYPE_MUTATION = gql6`
+  mutation adminUpdateResourceType($input: AdminUpdateResourceInputType!) {
+    adminUpdateResourceType(input: $input) {
+      data {
+        active
+        resourceId
+        resourceType
+      }
+      message
+    }
+  }
+`;
+var ADMIN_RESEND_USER_VERIFICATION_EMAIL_MUTATION = gql6`
+  mutation adminResendUserVerificationEmail($userId: ID!) {
+    adminResendUserVerificationEmail(userId: $userId) {
+      data
+      message
+    }
+  }
+`;
+var ADMIN_PERMANENTLY_DELETE_RESOURCE_MUTATION = gql6`
+  mutation adminPermanentlyDeleteResource(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+  ) {
+    adminPermanentlyDeleteResource(
+      resourceId: $resourceId
+      resourceType: $resourceType
+    ) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/admin/hooksMutation.ts
+var useAdminUpdateResourceType = () => {
+  const [adminUpdateResourceType, { loading, error }] = useMutation(ADMIN_UPDATE_RESOURCE_TYPE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const adminUpdateResourceType2 = mutationResult?.data?.adminUpdateResourceType?.data;
+      const resourceId = adminUpdateResourceType2?.resourceId;
+      const resourceType = adminUpdateResourceType2?.resourceType;
+      if (!resourceId) return [];
+      const detectQuery = resourceType === "event" /* EVENT */ ? GET_EVENT : GET_VENDOR;
+      return [
+        {
+          query: detectQuery,
+          variables: { _id: resourceId }
+        }
+      ];
+    }
+  });
+  return {
+    adminUpdateResourceType,
+    error,
+    loading
+  };
+};
+var useAdminResendUserVerificationEmail = () => {
+  const [adminResendUserVerificationEmail, { loading, error }] = useMutation(ADMIN_RESEND_USER_VERIFICATION_EMAIL_MUTATION);
+  return {
+    adminResendUserVerificationEmail,
+    error,
+    loading
+  };
+};
+var useAdminPermanentlyDeleteResource = () => {
+  const [adminPermanentlyDeleteResource, { loading, error }] = useMutation(ADMIN_PERMANENTLY_DELETE_RESOURCE_MUTATION);
+  return {
+    adminPermanentlyDeleteResource,
+    error,
+    loading
+  };
+};
+
+// src/graphql/hooks/chat/hooksMutation.ts
+import { useMutation as useMutation2 } from "@apollo/client";
+
+// src/graphql/mutations/chat.ts
+import { gql as gql8 } from "@apollo/client";
+
+// src/graphql/queries/chat.ts
+import { gql as gql7 } from "@apollo/client";
+var CHAT_MESSAGE_FIELDS_FRAGMENT = gql7`
+  fragment ChatMessageFields on ChatMessageType {
+    _id
+    content
+    createdAt
+    replyToMessageId
+    replyPreview {
+      senderId
+      senderName
+      contentPreview
+    }
+    likedBy {
+      userId
+      createdAt
+    }
+    senderId
+    seenBy {
+      userId
+      seenAt
+    }
+    updatedAt
+  }
+`;
+var CHAT_PARTICIPANT = gql7`
+  fragment ChatParticipantFields on ChatParticipantType {
+    active
+    userAvatar
+    userEmail
+    userId
+    userName
+  }
+`;
+var CHAT_FIELDS_FRAGMENT = gql7`
+  fragment ChatFields on ChatType {
+    _id
+    active
+    chatDescription
+    chatName
+    chatType
+    createdAt
+    deletedAt
+    messages {
+      ...ChatMessageFields
+    }
+    participants {
+      ...ChatParticipantFields
+    }
+    region
+    updatedAt
+  }
+  ${CHAT_MESSAGE_FIELDS_FRAGMENT}
+  ${CHAT_PARTICIPANT}
+`;
+var CHAT = gql7`
+  query chat($_id: ID!) {
+    chat(_id: $_id) {
+      ...ChatFields
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var USER_CHATS = gql7`
+  query userChats {
+    userChats {
+      ...ChatFields
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var GET_CHATS_BY_REGION = gql7`
+  query getChatsByRegion($region: String!) {
+    chatsByRegion(region: $region) {
+      ...ChatFields
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var CHAT_REPORT_FIELDS_FRAGMENT = gql7`
+  fragment ChatReportFields on ReportChatUserType {
+    _id
+    chatId
+    createdAt
+    reason {
+      reasonType
+      details
+    }
+    reportedUserId
+    reporterUserId
+    resolved
+    updatedAt
+  }
+`;
+var GET_REPORTED_CHAT_USERS = gql7`
+  query getReportedChatUsers {
+    reportedChatUsers {
+      ...ChatReportFields
+    }
+  }
+  ${CHAT_REPORT_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/chat.ts
+var CREATE_PRIVATE_CHAT_MUTATION = gql8`
+  mutation createPrivateChat($userId: ID!) {
+    createPrivateChat(userId: $userId) {
+      data {
+        ...ChatFields
+      }
+      message
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var SEND_CHAT_MESSAGE_MUTATION = gql8`
+  mutation sendChatMessage($_id: ID!, $input: ChatMessageInputType!) {
+    sendChatMessage(_id: $_id, input: $input) {
+      data {
+        ...ChatFields
+      }
+      message
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var DELETE_CHAT_MUTATION = gql8`
+  mutation deleteChat($_id: ID!) {
+    deleteChat(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var ADD_PARTICIPANT_TO_CHAT_MUTATION = gql8`
+  mutation addParticipantToChat($chatId: ID!, $userId: ID!) {
+    addParticipantToChat(chatId: $chatId, userId: $userId) {
+      data {
+        ...ChatFields
+      }
+      message
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var REMOVE_PARTICIPANT_FROM_CHAT_MUTATION = gql8`
+  mutation removeParticipantFromChat($chatId: ID!, $userId: ID!) {
+    removeParticipantFromChat(chatId: $chatId, userId: $userId) {
+      data {
+        success
+        region
+      }
+      message
+    }
+  }
+`;
+var TOGGLE_CHAT_MESSAGE_LIKE_MUTATION = gql8`
+  mutation toggleChatMessageLike($chatId: ID!, $messageId: ID!) {
+    toggleChatMessageLike(chatId: $chatId, messageId: $messageId) {
+      data {
+        ...ChatFields
+      }
+      message
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var MARK_CHAT_MESSAGES_SEEN_MUTATION = gql8`
+  mutation markChatMessagesSeen($chatId: ID!, $messageIds: [ID!]!) {
+    markChatMessagesSeen(chatId: $chatId, messageIds: $messageIds) {
+      data {
+        ...ChatFields
+      }
+      message
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+var REPORT_CHAT_USER_MUTATION = gql8`
+  mutation reportChatUser($input: ReportChatUserInputType!) {
+    reportChatUser(input: $input) {
+      data {
+        ...ChatReportFields
+      }
+      message
+    }
+  }
+  ${CHAT_REPORT_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/chat/hooksMutation.ts
+var useCreatePrivateChat = () => {
+  const [createPrivateChat, { loading, error }] = useMutation2(CREATE_PRIVATE_CHAT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: USER_CHATS }]
+  });
+  return { createPrivateChat, error, loading };
+};
+var useSendChatMessage = () => {
+  const [sendChatMessage, { loading, error }] = useMutation2(SEND_CHAT_MESSAGE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const chatId = mutationResult?.data?.sendChatMessage?.data?._id;
+      return [
+        {
+          query: CHAT,
+          variables: { _id: chatId }
+        }
+      ];
+    }
+  });
+  return { error, loading, sendChatMessage };
+};
+var useDeleteChat = () => {
+  const [deleteChat, { loading, error }] = useMutation2(DELETE_CHAT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: USER_CHATS }]
+  });
+  return { deleteChat, error, loading };
+};
+var useAddParticipantToChat = () => {
+  const [addParticipantToChat, { loading, error }] = useMutation2(ADD_PARTICIPANT_TO_CHAT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const chatId = mutationResult?.data?.addParticipantToChat?.data?._id;
+      return [
+        {
+          query: CHAT,
+          variables: { _id: chatId }
+        },
+        {
+          query: USER_CHATS
+        }
+      ];
+    }
+  });
+  return { addParticipantToChat, error, loading };
+};
+var useRemoveParticipantFromChat = () => {
+  const [removeParticipantFromChat, { loading, error }] = useMutation2(REMOVE_PARTICIPANT_FROM_CHAT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const region = mutationResult?.data?.removeParticipantFromChat?.data?.region;
+      const queries = [{ query: USER_CHATS }];
+      if (region && region.trim() !== "") {
+        queries.push({
+          query: GET_CHATS_BY_REGION,
+          variables: { region }
+        });
+      }
+      return queries;
+    }
+  });
+  return { error, loading, removeParticipantFromChat };
+};
+var useToggleChatMessageLike = () => {
+  const [toggleChatMessageLike, { loading, error }] = useMutation2(TOGGLE_CHAT_MESSAGE_LIKE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const chatId = mutationResult?.data?.toggleChatMessageLike?.data?._id;
+      return [
+        {
+          query: CHAT,
+          variables: { _id: chatId }
+        }
+      ];
+    }
+  });
+  return { error, loading, toggleChatMessageLike };
+};
+var useMarkChatMessagesSeen = () => {
+  const [markChatMessagesSeen, { loading, error }] = useMutation2(MARK_CHAT_MESSAGES_SEEN_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const chatId = mutationResult?.data?.markChatMessagesSeen?.data?._id;
+      return [
+        {
+          query: CHAT,
+          variables: { _id: chatId }
+        }
+      ];
+    }
+  });
+  return { error, loading, markChatMessagesSeen };
+};
+var useReportChatUser = () => {
+  const [reportChatUser, { loading, error }] = useMutation2(REPORT_CHAT_USER_MUTATION);
+  return { error, loading, reportChatUser };
+};
+
+// src/graphql/hooks/chat/hooksQuery.ts
+import { useQuery, useSubscription } from "@apollo/client";
+
+// src/graphql/subscriptions/chat.ts
+import { gql as gql9 } from "@apollo/client";
+var GET_CHAT_MESSAGE = gql9`
+  subscription {
+    getChatMessage {
+      ...ChatFields
+    }
+  }
+  ${CHAT_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/chat/hooksQuery.ts
+var useGetChat = (_id) => {
+  const { loading, error, data, refetch } = useQuery(CHAT, {
+    fetchPolicy: "network-only",
+    skip: !_id || _id === "",
+    variables: { _id }
+  });
+  const chat = data?.chat;
+  return { chat, error, loading, refetch };
+};
+var useGetUserChats = () => {
+  const { loading, error, data, refetch } = useQuery(
+    USER_CHATS,
+    {
+      fetchPolicy: "network-only"
+    }
+  );
+  const userChats = data?.userChats || [];
+  return { error, loading, refetch, userChats };
+};
+var useGetChatSubscription = () => {
+  const { data, loading, error } = useSubscription(
+    GET_CHAT_MESSAGE
+  );
+  const chat = data?.getChat;
+  return { chat, error, loading };
+};
+var useGetChatsByRegion = (region) => {
+  const { loading, error, data, refetch } = useQuery(GET_CHATS_BY_REGION, {
+    fetchPolicy: "network-only",
+    variables: { region }
+  });
+  const chatsByRegion = data?.chatsByRegion || [];
+  return { chatsByRegion, error, loading, refetch };
+};
+var useGetReportedChatUsers = () => {
+  const { loading, error, data, refetch } = useQuery(GET_REPORTED_CHAT_USERS, {
+    fetchPolicy: "network-only"
+  });
+  const reportedChatUsers = data?.reportedChatUsers || [];
+  return { error, loading, refetch, reportedChatUsers };
+};
+
+// src/graphql/hooks/contactUs.ts
+import { useMutation as useMutation3 } from "@apollo/client";
+
+// src/graphql/mutations/contactUs.ts
+import { gql as gql10 } from "@apollo/client";
+var CONTACT_US_MUTATION = gql10`
+  mutation contactUs($input: ContactUsInputType!) {
+    contactUs(input: $input) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/contactUs.ts
+var useContactUs = () => {
+  const [contactUs, { loading, error }] = useMutation3(CONTACT_US_MUTATION);
+  return { contactUs, error, loading };
+};
+
+// src/graphql/hooks/event/hooksMutation.ts
+import { useMutation as useMutation4 } from "@apollo/client";
+
+// src/graphql/mutations/event.ts
+import { gql as gql11 } from "@apollo/client";
+var CREATE_EVENT_MUTATION = gql11`
+  mutation createEvent($input: EventInputType!) {
+    createEvent(input: $input) {
+      data {
+        ...EventFields
+      }
+      message
+    }
+  }
+  ${EVENT}
+`;
+var UPDATE_EVENT_MUTATION = gql11`
+  mutation updateEvent($_id: ID!, $input: EventInputType!) {
+    updateEvent(_id: $_id, input: $input) {
+      data {
+        ...EventFields
+      }
+      message
+    }
+  }
+  ${EVENT}
+`;
+var DELETE_EVENT_MUTATION = gql11`
+  mutation deleteEvent($_id: ID!) {
+    deleteEvent(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var CREATE_EVENT_INFO_MUTATION = gql11`
+  mutation createEventInfo($input: EventInfoInputType!) {
+    createEventInfo(input: $input) {
+      data {
+        ...EventInfoFields
+      }
+      message
+    }
+  }
+  ${EVENT_INFO}
+`;
+var UPDATE_EVENT_INFO_MUTATION = gql11`
+  mutation updateEventInfo($_id: ID!, $input: EventInfoInputType!) {
+    updateEventInfo(_id: $_id, input: $input) {
+      data {
+        ...EventInfoFields
+      }
+      message
+    }
+  }
+  ${EVENT_INFO}
+`;
+
+// src/graphql/hooks/event/hooksMutation.ts
+var useCreateEvent = () => {
+  const [createEvent, { loading, error }] = useMutation4(CREATE_EVENT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_EVENTS }]
+  });
+  return { createEvent, error, loading };
+};
+var useUpdateEvent = () => {
+  const [updateEvent, { loading, error }] = useMutation4(UPDATE_EVENT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const eventId = mutationResult?.data?.updateEvent?.data?._id;
+      if (!eventId) return [];
+      return [
+        {
+          query: GET_USER_EVENTS
+        },
+        {
+          query: GET_EVENT,
+          variables: { _id: eventId }
+        },
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+        }
+      ];
+    }
+  });
+  return { error, loading, updateEvent };
+};
+var useDeleteEvent = () => {
+  const [deleteEvent, { loading, error }] = useMutation4(DELETE_EVENT_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_EVENTS }]
+  });
+  return { deleteEvent, error, loading };
+};
+var useCreateEventInfo = () => {
+  const [createEventInfo, { loading, error }] = useMutation4(CREATE_EVENT_INFO_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const eventId = mutationResult?.data?.createEventInfo?.data?.eventId;
+      if (!eventId) return [];
+      return [
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+          // Pass the eventId for refetching
+        },
+        {
+          query: GET_USER_EVENTS
+        },
+        {
+          query: GET_EVENT,
+          variables: { _id: eventId }
+        }
+      ];
+    }
+  });
+  return { createEventInfo, error, loading };
+};
+var useUpdateEventInfo = () => {
+  const [updateEventInfo, { loading, error }] = useMutation4(UPDATE_EVENT_INFO_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const eventId = mutationResult?.data?.updateEventInfo?.data?.eventId;
+      if (!eventId) return [];
+      return [
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+        },
+        {
+          query: GET_EVENT,
+          variables: { _id: eventId }
+        },
+        {
+          query: GET_USER_EVENTS
+        }
+      ];
+    }
+  });
+  return { error, loading, updateEventInfo };
+};
+
+// src/graphql/hooks/event/hooksQuery.ts
+import { useQuery as useQuery2 } from "@apollo/client";
+var useGetEvents = (dateStatus) => {
+  const { loading, error, data, refetch } = useQuery2(GET_EVENTS, {
+    fetchPolicy: "network-only",
+    variables: { dateStatus }
+  });
+  const events = data?.events || [];
+  return { error, events, loading, refetch };
+};
+var useGetEvent = (_id) => {
+  const { loading, error, data, refetch } = useQuery2(GET_EVENT, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: { _id }
+  });
+  const event = data?.event || null;
+  return { error, event, loading, refetch };
+};
+var useGetEventByPlaceId = (googlePlaceId) => {
+  const { loading, error, data, refetch } = useQuery2(GET_EVENT_BY_PLACE_ID, {
+    fetchPolicy: "network-only",
+    skip: !googlePlaceId,
+    variables: { googlePlaceId }
+  });
+  const eventByPlaceId = data?.eventByPlaceId || null;
+  return { error, eventByPlaceId, loading, refetch };
+};
+var useGetEventsByRegion = (region, options, dateStatus) => {
+  const variables = {
+    dateStatus,
+    options,
+    region
+  };
+  const { loading, error, data, refetch, fetchMore } = useQuery2(GET_EVENTS_BY_REGION, {
+    fetchPolicy: "network-only",
+    skip: !region || region === "",
+    variables
+  });
+  const eventsByRegion = data?.eventsByRegion || [];
+  return {
+    error,
+    eventsByRegion,
+    fetchMore,
+    loading,
+    refetch
+  };
+};
+var useSearchEvents = (region, searchQuery, tags, dateStatus) => {
+  const normalizedSearch = searchQuery?.trim() ?? "";
+  const normalizedTags = (tags ?? []).filter(Boolean);
+  const shouldRunQuery = normalizedSearch.length > 3 || normalizedTags.length > 0;
+  const { loading, error, data, refetch } = useQuery2(SEARCH_EVENTS, {
+    fetchPolicy: "network-only",
+    skip: !shouldRunQuery,
+    variables: {
+      dateStatus,
+      region,
+      search: normalizedSearch,
+      tags: normalizedTags
+    }
+  });
+  return {
+    error,
+    eventsSearch: data?.eventsSearch ?? [],
+    loading,
+    refetch
+  };
+};
+var useGetEventsNearMe = (location, dateStatus) => {
+  const { loading, error, data, refetch } = useQuery2(GET_EVENTS_NEAR_ME, {
+    fetchPolicy: "network-only",
+    skip: !location.latitude || !location.longitude,
+    variables: {
+      dateStatus,
+      latitude: location.latitude,
+      longitude: location.longitude,
+      radius: location.radius || 1e4
+      // Default to 10km if no radius is provided
+    }
+  });
+  const eventsNearMe = data?.eventsNearMe || [];
+  return { error, eventsNearMe, loading, refetch };
+};
+var useGetEventInfo = (eventId) => {
+  const { loading, error, data, refetch } = useQuery2(GET_EVENT_INFO, {
+    fetchPolicy: "network-only",
+    skip: !eventId || eventId === "",
+    variables: { eventId }
+  });
+  const eventInfo = data?.eventInfo;
+  return { error, eventInfo, loading, refetch };
+};
+
+// src/graphql/hooks/notifications/hooksMutation.ts
+import { useMutation as useMutation5 } from "@apollo/client";
+
+// src/graphql/mutations/notification.ts
+import { gql as gql13 } from "@apollo/client";
+
+// src/graphql/queries/notification.ts
+import { gql as gql12 } from "@apollo/client";
+var NOTIFICATION_FRAGMENT = gql12`
+  fragment NotificationFields on Notification {
+    _id
+    userId
+    title
+    message
+    type
+    isRead
+    data {
+      resourceId
+      resourceName
+      resourceType
+    }
+    createdAt
+    updatedAt
+  }
+`;
+var GET_USER_NOTIFICATIONS = gql12`
+  query getUserNotifications($limit: Int, $offset: Int) {
+    userNotifications(limit: $limit, offset: $offset) {
+      ...NotificationFields
+    }
+  }
+  ${NOTIFICATION_FRAGMENT}
+`;
+var GET_NOTIFICATION_COUNT = gql12`
+  query getNotificationCount {
+    notificationCount {
+      total
+      unread
+    }
+  }
+`;
+
+// src/graphql/mutations/notification.ts
+var CREATE_BULK_NOTIFICATIONS = gql13`
+  mutation createBulkNotifications($input: CreateBulkNotificationInput!) {
+    createBulkNotifications(input: $input) {
+      data
+      message
+    }
+  }
+`;
+var MARK_NOTIFICATION_READ = gql13`
+  mutation markNotificationRead($_id: ID!) {
+    markNotificationRead(_id: $_id) {
+      data {
+        ...NotificationFields
+      }
+      message
+    }
+  }
+  ${NOTIFICATION_FRAGMENT}
+`;
+var MARK_ALL_NOTIFICATIONS_READ = gql13`
+  mutation markAllNotificationsRead {
+    markAllNotificationsRead {
+      data
+      message
+    }
+  }
+`;
+var DELETE_NOTIFICATION = gql13`
+  mutation deleteNotification($_id: ID!) {
+    deleteNotification(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var DELETE_ALL_NOTIFICATIONS = gql13`
+  mutation deleteAllNotifications {
+    deleteAllNotifications {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/notifications/hooksMutation.ts
+var useCreateBulkNotifications = () => {
+  const [createBulkNotifications, { loading, error }] = useMutation5(CREATE_BULK_NOTIFICATIONS);
+  return { createBulkNotifications, error, loading };
+};
+var useMarkNotificationRead = () => {
+  const [markNotificationRead, { loading, error }] = useMutation5(MARK_NOTIFICATION_READ, {
+    refetchQueries: [
+      {
+        query: GET_USER_NOTIFICATIONS
+      },
+      {
+        query: GET_NOTIFICATION_COUNT
+      }
+    ]
+  });
+  return { error, loading, markNotificationRead };
+};
+var useMarkAllNotificationsRead = () => {
+  const [markAllNotificationsRead, { loading, error }] = useMutation5(MARK_ALL_NOTIFICATIONS_READ, {
+    refetchQueries: [
+      {
+        query: GET_USER_NOTIFICATIONS
+      },
+      {
+        query: GET_NOTIFICATION_COUNT
+      }
+    ]
+  });
+  return { error, loading, markAllNotificationsRead };
+};
+var useDeleteNotification = () => {
+  const [deleteNotification, { loading, error }] = useMutation5(DELETE_NOTIFICATION, {
+    refetchQueries: [
+      {
+        query: GET_USER_NOTIFICATIONS
+      },
+      {
+        query: GET_NOTIFICATION_COUNT
+      }
+    ]
+  });
+  return { deleteNotification, error, loading };
+};
+var useDeleteAllNotifications = () => {
+  const [deleteAllNotifications, { loading, error }] = useMutation5(DELETE_ALL_NOTIFICATIONS, {
+    refetchQueries: [
+      {
+        query: GET_USER_NOTIFICATIONS
+      },
+      {
+        query: GET_NOTIFICATION_COUNT
+      }
+    ]
+  });
+  return { deleteAllNotifications, error, loading };
+};
+
+// src/graphql/hooks/notifications/hooksQuery.ts
+import { useQuery as useQuery3 } from "@apollo/client";
+var useGetUserNotifications = (limit, offset) => {
+  const { data, loading, error, refetch } = useQuery3(GET_USER_NOTIFICATIONS, {
+    fetchPolicy: "no-cache",
+    variables: { limit, offset }
+  });
+  return {
+    error,
+    loading,
+    notifications: data?.userNotifications || [],
+    refetch
+  };
+};
+var useGetNotificationCount = () => {
+  const { data, loading, error, refetch } = useQuery3(GET_NOTIFICATION_COUNT, {
+    fetchPolicy: "no-cache"
+  });
+  return {
+    error,
+    loading,
+    notificationCount: data?.notificationCount || { total: 0, unread: 0 },
+    refetch
+  };
+};
+
+// src/graphql/hooks/notifications/hooksSubscription.ts
+import { useSubscription as useSubscription2 } from "@apollo/client";
+
+// src/graphql/subscriptions/notification.ts
+import { gql as gql14 } from "@apollo/client";
+var GET_NOTIFICATIONS_SUBSCRIPTION = gql14`
+  subscription {
+    getUserNotifications {
+      ...NotificationFields
+    }
+  }
+  ${NOTIFICATION_FRAGMENT}
+`;
+var GET_NOTIFICATION_COUNT_SUBSCRIPTION = gql14`
+  subscription {
+    getNotificationCount {
+      total
+      unread
+    }
+  }
+`;
+
+// src/graphql/hooks/notifications/hooksSubscription.ts
+var useGetUserNotificationsSubscription = () => {
+  const { data, loading, error } = useSubscription2(GET_NOTIFICATIONS_SUBSCRIPTION, {
+    fetchPolicy: "no-cache",
+    shouldResubscribe: true
+  });
+  return {
+    error,
+    loading,
+    notifications: data?.getUserNotifications
+  };
+};
+var useGetNotificationCountSubscription = () => {
+  const { data, loading, error } = useSubscription2(GET_NOTIFICATION_COUNT_SUBSCRIPTION, {
+    fetchPolicy: "no-cache",
+    shouldResubscribe: true
+  });
+  return {
+    error,
+    loading,
+    notificationCount: data?.getNotificationCount
+  };
+};
+
+// src/graphql/hooks/poster.ts
+import { useMutation as useMutation6 } from "@apollo/client";
+
+// src/graphql/mutations/poster.ts
+import { gql as gql15 } from "@apollo/client";
+var CREATE_POSTER_MUTATION = gql15`
+  mutation createPoster($input: PosterInputType!) {
+    createPoster(input: $input) {
+      data {
+        posterUsage {
+          ...PosterUsageFields
+        }
+      }
+      message
+    }
+  }
+  ${POSTER_USAGE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/poster.ts
+var useCreatePoster = () => {
+  const [createPoster, { loading, error }] = useMutation6(CREATE_POSTER_MUTATION, {
+    refetchQueries: [{ query: GET_USER_EVENTS }, { query: GET_USER_VENDORS }]
+  });
+  return { createPoster, error, loading };
+};
+
+// src/graphql/hooks/pushToken.ts
+import { useMutation as useMutation7 } from "@apollo/client";
+
+// src/graphql/mutations/pushToken.ts
+import { gql as gql16 } from "@apollo/client";
+var CREATE_PUSH_TOKEN_MUTATION = gql16`
+  mutation createPushToken($input: PushTokenInput!) {
+    createPushToken(input: $input) {
+      data {
+        success
+      }
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/pushToken.ts
+var useCreatePushToken = () => {
+  const [createPushToken, { loading, error }] = useMutation7(CREATE_PUSH_TOKEN_MUTATION);
+  return { createPushToken, error, loading };
+};
+
+// src/graphql/hooks/relation/hooksMutation.ts
+import { useMutation as useMutation8 } from "@apollo/client";
+
+// src/graphql/mutations/relation.ts
+import { gql as gql17 } from "@apollo/client";
+var CREATE_RELATION_MUTATION = gql17`
+  mutation createRelation($input: RelationInputType!) {
+    createRelation(input: $input) {
+      data {
+        ...RelationFields
+      }
+      message
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var UPDATE_RELATION_MUTATION = gql17`
+  mutation updateRelation($_id: ID!, $input: RelationInputType!) {
+    updateRelation(_id: $_id, input: $input) {
+      data {
+        ...RelationFields
+      }
+      message
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var DELETE_RELATION_MUTATION = gql17`
+  mutation deleteRelation($_id: ID!) {
+    deleteRelation(_id: $_id) {
+      data {
+        ...RelationFields
+      }
+      message
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/relation/hooksMutation.ts
+var useCreateRelation = () => {
+  const [createRelation, { loading, error }] = useMutation8(CREATE_RELATION_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const createRelation2 = mutationResult?.data?.createRelation?.data;
+      const eventId = createRelation2?.eventId;
+      const vendorId = createRelation2?.vendorId;
+      const resourceType = createRelation2?.lastUpdateBy;
+      const resourceId = resourceType === "event" /* EVENT */ ? eventId : vendorId;
+      return [
+        {
+          query: GET_EVENT_RELATIONS,
+          variables: { eventId }
+        },
+        {
+          query: GET_EVENT,
+          variables: { _id: eventId }
+        },
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+        },
+        {
+          query: GET_VENDOR_RELATIONS,
+          variables: { vendorId }
+        },
+        {
+          query: GET_VENDOR,
+          variables: { _id: vendorId }
+        },
+        {
+          query: GET_RELATION_BY_EVENT_AND_VENDOR,
+          variables: { eventId, vendorId }
+        },
+        {
+          query: GET_RESOURCE_CONNECTIONS,
+          variables: { resourceId, resourceType }
+        },
+        {
+          query: USER_CHATS
+        }
+      ];
+    }
+  });
+  return { createRelation, error, loading };
+};
+var useUpdateRelation = () => {
+  const [updateRelation, { loading, error }] = useMutation8(UPDATE_RELATION_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const updateRelation2 = mutationResult?.data?.updateRelation?.data;
+      const eventId = updateRelation2?.eventId;
+      const vendorId = updateRelation2?.vendorId;
+      const resourceType = updateRelation2?.lastUpdateBy;
+      const resourceId = resourceType === "event" /* EVENT */ ? eventId : vendorId;
+      return [
+        {
+          query: GET_EVENT_RELATIONS,
+          variables: { eventId }
+        },
+        {
+          query: GET_EVENT,
+          variables: { _id: eventId }
+        },
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+        },
+        {
+          query: GET_VENDOR_RELATIONS,
+          variables: { vendorId }
+        },
+        {
+          query: GET_VENDOR,
+          variables: { _id: vendorId }
+        },
+        {
+          query: GET_RELATION_BY_EVENT_AND_VENDOR,
+          variables: { eventId, vendorId }
+        },
+        {
+          query: GET_RESOURCE_CONNECTIONS,
+          variables: { resourceId, resourceType }
+        }
+      ];
+    }
+  });
+  return { error, loading, updateRelation };
+};
+var useDeleteRelation = () => {
+  const [deleteRelation, { loading, error }] = useMutation8(DELETE_RELATION_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const deleteRelation2 = mutationResult?.data?.deleteRelation?.data;
+      const eventId = deleteRelation2?.eventId;
+      const vendorId = deleteRelation2?.vendorId;
+      const resourceType = deleteRelation2?.lastUpdateBy;
+      const resourceId = resourceType === "event" /* EVENT */ ? eventId : vendorId;
+      return [
+        {
+          query: GET_EVENT_INFO,
+          variables: { eventId }
+        },
+        {
+          query: GET_EVENT_RELATIONS,
+          variables: { eventId }
+        },
+        {
+          query: GET_VENDOR_RELATIONS,
+          variables: { vendorId }
+        },
+        {
+          query: GET_RELATION_BY_EVENT_AND_VENDOR,
+          variables: { eventId, vendorId }
+        },
+        {
+          query: GET_RESOURCE_CONNECTIONS,
+          variables: { resourceId, resourceType }
+        },
+        {
+          query: USER_CHATS
+        }
+      ];
+    }
+  });
+  return { deleteRelation, error, loading };
+};
+
+// src/graphql/hooks/relation/hooksQuery.ts
+import { useQuery as useQuery4 } from "@apollo/client";
+var useGetRelation = (_id) => {
+  const { loading, error, data, refetch } = useQuery4(GET_RELATION, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: _id ? { _id } : void 0
+  });
+  const relation = data?.relation;
+  return { error, loading, refetch, relation };
+};
+var useGetRelationByEventAndVendor = (eventId, vendorId) => {
+  const { loading, error, data, refetch } = useQuery4(GET_RELATION_BY_EVENT_AND_VENDOR, {
+    fetchPolicy: "network-only",
+    skip: !eventId || eventId === "" || !vendorId || vendorId === "",
+    variables: { eventId, vendorId }
+  });
+  const relationByEventAndVendor = data?.relationByEventAndVendor;
+  return { error, loading, refetch, relationByEventAndVendor };
+};
+var useGetEventRelations = (eventId) => {
+  const { loading, error, data, refetch } = useQuery4(GET_EVENT_RELATIONS, {
+    fetchPolicy: "network-only",
+    skip: !eventId || eventId === "",
+    variables: { eventId }
+  });
+  const eventRelations = data?.eventRelations || [];
+  return { error, eventRelations, loading, refetch };
+};
+var useGetVendorRelations = (vendorId) => {
+  const { loading, error, data, refetch } = useQuery4(GET_VENDOR_RELATIONS, {
+    fetchPolicy: "network-only",
+    skip: !vendorId || vendorId === "",
+    variables: { vendorId }
+  });
+  const vendorRelations = data?.vendorRelations || [];
+  return { error, loading, refetch, vendorRelations };
+};
+var useGetResourceConnections = (resourceId, resourceType) => {
+  const { loading, error, data, refetch } = useQuery4(GET_RESOURCE_CONNECTIONS, {
+    fetchPolicy: "network-only",
+    skip: !resourceId || resourceId === "" || !resourceType,
+    variables: { resourceId, resourceType }
+  });
+  const resourceConnections = data?.resourceConnections;
+  return { error, loading, refetch, resourceConnections };
+};
+
+// src/graphql/hooks/vendor/hooksMutation.ts
+import { useMutation as useMutation9 } from "@apollo/client";
+
+// src/graphql/mutations/vendor.ts
+import { gql as gql18 } from "@apollo/client";
+var CREATE_VENDOR_MUTATION = gql18`
+  mutation createVendor($input: VendorInputType!) {
+    createVendor(input: $input) {
+      data {
+        ...VendorFields
+      }
+      message
+    }
+  }
+  ${VENDOR}
+`;
+var UPDATE_VENDOR_MUTATION = gql18`
+  mutation updateVendor($_id: ID!, $input: VendorInputType!) {
+    updateVendor(_id: $_id, input: $input) {
+      data {
+        ...VendorFields
+      }
+      message
+    }
+  }
+  ${VENDOR}
+`;
+var DELETE_VENDOR_MUTATION = gql18`
+  mutation deleteVendor($_id: ID!) {
+    deleteVendor(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var CREATE_VENDOR_INFO_MUTATION = gql18`
+  mutation createVendorInfo($input: VendorInfoInputType!) {
+    createVendorInfo(input: $input) {
+      data {
+        ...VendorInfoFields
+      }
+      message
+    }
+  }
+  ${VENDOR_INFO}
+`;
+var UPDATE_VENDOR_INFO_MUTATION = gql18`
+  mutation updateVendorInfo($_id: ID!, $input: VendorInfoInputType!) {
+    updateVendorInfo(_id: $_id, input: $input) {
+      data {
+        ...VendorInfoFields
+      }
+      message
+    }
+  }
+  ${VENDOR_INFO}
+`;
+var CREATE_UNREGISTERED_VENDOR_MUTATION = gql18`
+  mutation createUnregisteredVendor($input: UnregisteredVendorInputType!) {
+    createUnregisteredVendor(input: $input) {
+      data {
+        ...UnregisteredVendorFields
+      }
+      message
+    }
+  }
+  ${UNREGISTERED_VENDOR}
+`;
+var UPDATE_UNREGISTERED_VENDOR_MUTATION = gql18`
+  mutation updateUnregisteredVendor(
+    $_id: ID!
+    $input: UnregisteredVendorInputType!
+  ) {
+    updateUnregisteredVendor(_id: $_id, input: $input) {
+      data {
+        ...UnregisteredVendorFields
+      }
+      message
+    }
+  }
+  ${UNREGISTERED_VENDOR}
+`;
+var DELETE_UNREGISTERED_VENDOR_MUTATION = gql18`
+  mutation deleteUnregisteredVendor($_id: ID!) {
+    deleteUnregisteredVendor(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var UNLINK_UNREGISTERED_VENDOR_BY_INVITER_ID_MUTATION = gql18`
+  mutation unlinkUnregisteredVendorByInviterId($_id: ID!, $inviterId: ID!) {
+    unlinkUnregisteredVendorByInviterId(_id: $_id, inviterId: $inviterId) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/vendor/hooksMutation.ts
+var useCreateVendor = () => {
+  const [createVendor, { loading, error }] = useMutation9(CREATE_VENDOR_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_VENDORS }]
+  });
+  return { createVendor, error, loading };
+};
+var useUpdateVendor = () => {
+  const [updateVendor, { loading, error }] = useMutation9(UPDATE_VENDOR_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_VENDORS }]
+  });
+  return { error, loading, updateVendor };
+};
+var useDeleteVendor = () => {
+  const [deleteVendor, { loading, error }] = useMutation9(DELETE_VENDOR_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_VENDORS }]
+  });
+  return { deleteVendor, error, loading };
+};
+var useCreateVendorInfo = () => {
+  const [createVendorInfo, { loading, error }] = useMutation9(CREATE_VENDOR_INFO_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const vendorId = mutationResult?.data?.createVendorInfo?.data?.vendorId;
+      if (!vendorId) return [];
+      return [
+        {
+          query: GET_VENDOR_INFO,
+          variables: { vendorId }
+          // Pass the vendorId for refetching
+        },
+        {
+          query: GET_USER_VENDORS
+        },
+        {
+          query: GET_VENDOR,
+          variables: { _id: vendorId }
+        }
+      ];
+    }
+  });
+  return { createVendorInfo, error, loading };
+};
+var useUpdateVendorInfo = () => {
+  const [updateVendorInfo, { loading, error }] = useMutation9(UPDATE_VENDOR_INFO_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const vendorId = mutationResult?.data?.updateVendorInfo?.data?.vendorId;
+      if (!vendorId) return [];
+      return [
+        {
+          query: GET_VENDOR_INFO,
+          variables: { vendorId }
+          // Pass the vendorId for refetching
+        }
+      ];
+    }
+  });
+  return { error, loading, updateVendorInfo };
+};
+var useCreateUnregisteredVendor = () => {
+  const [createUnregisteredVendor, { loading, error }] = useMutation9(CREATE_UNREGISTERED_VENDOR_MUTATION);
+  return { createUnregisteredVendor, error, loading };
+};
+var useUpdateUnregisteredVendor = () => {
+  const [updateUnregisteredVendor, { loading, error }] = useMutation9(UPDATE_UNREGISTERED_VENDOR_MUTATION);
+  return { error, loading, updateUnregisteredVendor };
+};
+var useDeleteUnregisteredVendor = () => {
+  const [deleteUnregisteredVendor, { loading, error }] = useMutation9(DELETE_UNREGISTERED_VENDOR_MUTATION);
+  return { deleteUnregisteredVendor, error, loading };
+};
+var useUnlinkUnregisteredVendorByInviterId = () => {
+  const [unlinkUnregisteredVendorByInviterId, { loading, error }] = useMutation9(UNLINK_UNREGISTERED_VENDOR_BY_INVITER_ID_MUTATION);
+  return { error, loading, unlinkUnregisteredVendorByInviterId };
+};
+
+// src/graphql/hooks/vendor/hooksQuery.ts
+import { useQuery as useQuery5 } from "@apollo/client";
+var useGetVendors = () => {
+  const { loading, error, data, refetch } = useQuery5(
+    GET_VENDORS,
+    {
+      fetchPolicy: "network-only"
+    }
+  );
+  const vendors = data?.vendors || [];
+  return {
+    error,
+    loading,
+    refetch,
+    vendors
+  };
+};
+var useGetVendor = (_id) => {
+  const { loading, error, data, refetch } = useQuery5(
+    GET_VENDOR,
+    {
+      fetchPolicy: "network-only",
+      skip: !_id || _id === "",
+      variables: { _id }
+    }
+  );
+  const vendor = data?.vendor;
+  return { error, loading, refetch, vendor };
+};
+var useGetVendorsByRegion = (region, options) => {
+  const variables = {
+    options,
+    region
+  };
+  const { loading, error, data, refetch, fetchMore } = useQuery5(GET_VENDORS_BY_REGION, {
+    fetchPolicy: "network-only",
+    variables
+  });
+  const vendorsByRegion = data?.vendorsByRegion || [];
+  return {
+    error,
+    fetchMore,
+    loading,
+    refetch,
+    vendorsByRegion
+  };
+};
+var useSearchVendors = (search, region) => {
+  const { loading, error, data, refetch } = useQuery5(SEARCH_VENDORS, {
+    fetchPolicy: "network-only",
+    skip: search.length < 3,
+    variables: { region, search }
+  });
+  const vendorSearch = data?.vendorSearch || [];
+  return { error, loading, refetch, vendorSearch };
+};
+var useGetVendorInfo = (vendorId) => {
+  const { loading, error, data, refetch } = useQuery5(GET_VENDOR_INFO, {
+    fetchPolicy: "network-only",
+    skip: !vendorId || vendorId === "",
+    variables: { vendorId }
+  });
+  const vendorInfo = data?.vendorInfo;
+  return {
+    error,
+    loading,
+    refetch,
+    vendorInfo
+  };
+};
+var useGetUnregisteredVendors = () => {
+  const { loading, error, data, refetch } = useQuery5(GET_UNREGISTERED_VENDORS, {
+    fetchPolicy: "network-only"
+  });
+  const unregisteredVendors = data?.unregisteredVendors || [];
+  return {
+    error,
+    loading,
+    refetch,
+    unregisteredVendors
+  };
+};
+var useGetUnregisteredVendorsByInviterId = (inviterId) => {
+  const { loading, error, data, refetch } = useQuery5(GET_UNREGISTERED_VENDORS_BY_INVITER_ID, {
+    fetchPolicy: "network-only",
+    skip: !inviterId || inviterId === "",
+    variables: { inviterId }
+  });
+  const unregisteredVendorsByInviterId = data?.unregisteredVendorsByInviterId || [];
+  return { error, loading, refetch, unregisteredVendorsByInviterId };
+};
+var useGetUnregisteredVendor = (_id) => {
+  const { loading, error, data, refetch } = useQuery5(GET_UNREGISTERED_VENDOR, {
+    fetchPolicy: "network-only",
+    skip: !_id || _id === "",
+    variables: { _id }
+  });
+  const unregisteredVendor = data?.unregisteredVendor;
+  return { error, loading, refetch, unregisteredVendor };
+};
+
+// src/graphql/hooks/user/hooksMutation.ts
+import { useMutation as useMutation10 } from "@apollo/client";
+
+// src/graphql/mutations/user.ts
+import { gql as gql19 } from "@apollo/client";
+var CREATE_USER_MUTATION = gql19`
+  mutation createUser($input: UserInputType!) {
+    createUser(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var UPDATE_USER_MUTATION = gql19`
+  mutation updateUser($_id: ID!, $input: UserInputType!) {
+    updateUser(_id: $_id, input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var DELETE_USER_MUTATION = gql19`
+  mutation deleteUser($email: String!) {
+    deleteUser(email: $email) {
+      data
+      message
+    }
+  }
+`;
+var REDEEM_REWARD_MUTATION = gql19`
+  mutation redeemReward($input: RedeemRewardInputType!) {
+    redeemReward(input: $input) {
+      data {
+        userId
+      }
+      message
+    }
+  }
+`;
+var ADD_USER_FAVOURITE_RESOURCE_MUTATION = gql19`
+  mutation addUserFavouriteResource(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+  ) {
+    addUserFavouriteResource(
+      resourceId: $resourceId
+      resourceType: $resourceType
+    ) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REMOVE_USER_FAVOURITE_RESOURCE_MUTATION = gql19`
+  mutation removeUserFavouriteResource(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+  ) {
+    removeUserFavouriteResource(
+      resourceId: $resourceId
+      resourceType: $resourceType
+    ) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var ADD_USER_INTEREST_RESOURCE_MUTATION = gql19`
+  mutation addUserInterestResource($input: UserActivityInputType!) {
+    addUserInterestResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REMOVE_USER_INTEREST_RESOURCE_MUTATION = gql19`
+  mutation removeUserInterestResource($input: UserActivityInputType!) {
+    removeUserInterestResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var ADD_USER_GOING_RESOURCE_MUTATION = gql19`
+  mutation addUserGoingResource($input: UserActivityInputType!) {
+    addUserGoingResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REMOVE_USER_GOING_RESOURCE_MUTATION = gql19`
+  mutation removeUserGoingResource($input: UserActivityInputType!) {
+    removeUserGoingResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var ADD_USER_PRESENT_RESOURCE_MUTATION = gql19`
+  mutation addUserPresentResource($input: UserActivityInputType!) {
+    addUserPresentResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REMOVE_USER_PRESENT_RESOURCE_MUTATION = gql19`
+  mutation removeUserPresentResource($input: UserActivityInputType!) {
+    removeUserPresentResource(input: $input) {
+      data {
+        ...UserFields
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var SELECT_STANDARD_PACKAGE_MUTATION = gql19`
+  mutation selectStandardPackage($selectedLicence: LicencesEnumType!) {
+    selectStandardPackage(selectedLicence: $selectedLicence) {
+      data {
+        licences {
+          ...LicenceFields
+        }
+        userId
+      }
+      message
+    }
+  }
+  ${LICENCE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/user/hooksMutation.ts
+var useCreateUser = () => {
+  const [createUser, { loading, error }] = useMutation10(CREATE_USER_MUTATION);
+  return { createUser, error, loading };
+};
+var useUpdateUser = () => {
+  const [updateUser, { loading, error }] = useMutation10(UPDATE_USER_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const userId = mutationResult?.data?.updateUser?.data?._id;
+      if (!userId) return [];
+      return [{ query: GET_USER, variables: { _id: userId } }];
+    }
+  });
+  return { error, loading, updateUser };
+};
+var useDeleteUser = () => {
+  const [deleteUser, { loading, error }] = useMutation10(DELETE_USER_MUTATION);
+  return { deleteUser, error, loading };
+};
+var useRedeemReward = () => {
+  const [redeemReward, { loading, error }] = useMutation10(REDEEM_REWARD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const userId = mutationResult?.data?.redeemReward?.data?.userId;
+      if (!userId) return [];
+      return [
+        {
+          query: GET_USER,
+          variables: { _id: userId }
+          // Pass the userId for refetching
+        }
+      ];
+    }
+  });
+  return { error, loading, redeemReward };
+};
+var useAddUserFavouriteResource = () => {
+  const [addUserFavouriteResource, { loading, error }] = useMutation10(ADD_USER_FAVOURITE_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { addUserFavouriteResource, error, loading };
+};
+var useRemoveUserFavouriteResource = () => {
+  const [removeUserFavouriteResource, { loading, error }] = useMutation10(REMOVE_USER_FAVOURITE_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { error, loading, removeUserFavouriteResource };
+};
+var useAddUserInterestResource = () => {
+  const [addUserInterestResource, { loading, error }] = useMutation10(ADD_USER_INTEREST_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { addUserInterestResource, error, loading };
+};
+var useRemoveUserInterestResource = () => {
+  const [removeUserInterestResource, { loading, error }] = useMutation10(REMOVE_USER_INTEREST_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { error, loading, removeUserInterestResource };
+};
+var useAddUserGoingResource = () => {
+  const [addUserGoingResource, { loading, error }] = useMutation10(ADD_USER_GOING_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { addUserGoingResource, error, loading };
+};
+var useRemoveUserGoingResource = () => {
+  const [removeUserGoingResource, { loading, error }] = useMutation10(REMOVE_USER_GOING_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { error, loading, removeUserGoingResource };
+};
+var useAddUserPresentResource = () => {
+  const [addUserPresentResource, { loading, error }] = useMutation10(ADD_USER_PRESENT_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { addUserPresentResource, error, loading };
+};
+var useRemoveUserPresentResource = () => {
+  const [removeUserPresentResource, { loading, error }] = useMutation10(REMOVE_USER_PRESENT_RESOURCE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_ACTIVITIES }]
+  });
+  return { error, loading, removeUserPresentResource };
+};
+var useSelectStandardPackage = () => {
+  const [selectStandardPackage, { loading, error }] = useMutation10(SELECT_STANDARD_PACKAGE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const userId = mutationResult?.data?.selectStandardPackage?.data?.userId;
+      if (!userId) return [];
+      return [
+        { query: GET_USER, variables: { _id: userId } },
+        { query: GET_USER_EVENTS },
+        { query: GET_USER_VENDORS }
+      ];
+    }
+  });
+  return { error, loading, selectStandardPackage };
+};
+
+// src/graphql/hooks/ad/hooksMutation.ts
+import { useMutation as useMutation11 } from "@apollo/client";
+
+// src/graphql/mutations/ad.ts
+import { gql as gql21 } from "@apollo/client";
+
+// src/graphql/queries/ad.ts
+import { gql as gql20 } from "@apollo/client";
+var AD_FIELDS_FRAGMENT = gql20`
+  fragment AdFields on AdType {
+    _id
+    active
+    clicks
+    createdAt
+    end
+    impressions
+    resource {
+      adDescription
+      adImage
+      adStyle
+      adTitle
+      adType
+      resourceId
+      resourceSlug
+      resourceName
+      resourceRegion
+      resourceType
+    }
+    showOn
+    start
+    status
+    targetRegion
+    updatedAt
+  }
+`;
+var GET_ADS = gql20`
+  query getAds {
+    ads {
+      ...AdFields
+    }
+  }
+  ${AD_FIELDS_FRAGMENT}
+`;
+var GET_AD = gql20`
+  query getAd($_id: ID!) {
+    ad(_id: $_id) {
+      ...AdFields
+    }
+  }
+  ${AD_FIELDS_FRAGMENT}
+`;
+var GET_ADS_BY_REGION = gql20`
+  query getAdsByRegion($region: String!, $status: AdStatusTypeEnum) {
+    adsByRegion(region: $region, status: $status) {
+      ...AdFields
+    }
+  }
+  ${AD_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/ad.ts
+var CREATE_AD_MUTATION = gql21`
+  mutation createAd($input: AdInputType!) {
+    createAd(input: $input) {
+      data {
+        ...AdFields
+      }
+      message
+    }
+  }
+  ${AD_FIELDS_FRAGMENT}
+`;
+var UPDATE_AD_MUTATION = gql21`
+  mutation updateAd($_id: ID!, $input: AdInputType!) {
+    updateAd(_id: $_id, input: $input) {
+      data {
+        ...AdFields
+      }
+      message
+    }
+  }
+  ${AD_FIELDS_FRAGMENT}
+`;
+var DELETE_AD_MUTATION = gql21`
+  mutation deleteAd($_id: ID!) {
+    deleteAd(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/ad/hooksMutation.ts
+var useCreateAd = () => {
+  const [createAd, { loading, error }] = useMutation11(CREATE_AD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_ADS }]
+  });
+  return {
+    createAd,
+    error,
+    loading
+  };
+};
+var useUpdateAd = () => {
+  const [updateAd, { loading, error }] = useMutation11(UPDATE_AD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_ADS }]
+  });
+  return {
+    error,
+    loading,
+    updateAd
+  };
+};
+var useDeleteAd = () => {
+  const [deleteAd, { loading, error }] = useMutation11(DELETE_AD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_ADS }]
+  });
+  return {
+    deleteAd,
+    error,
+    loading
+  };
+};
+
+// src/graphql/hooks/ad/hooksQuery.ts
+import { useQuery as useQuery6 } from "@apollo/client";
+var useGetAds = () => {
+  const { data, loading, error, refetch } = useQuery6(
+    GET_ADS,
+    {
+      fetchPolicy: "no-cache"
+    }
+  );
+  return {
+    ads: data?.ads || [],
+    error,
+    loading,
+    refetch
+  };
+};
+var useGetAd = (_id) => {
+  const { data, loading, error, refetch } = useQuery6(GET_AD, {
+    fetchPolicy: "no-cache",
+    skip: !_id || _id === "",
+    variables: { _id }
+  });
+  return {
+    ad: data?.ad,
+    error,
+    loading,
+    refetch
+  };
+};
+var useGetAdsByRegion = (region, status) => {
+  const { data, loading, error, refetch } = useQuery6(GET_ADS_BY_REGION, {
+    fetchPolicy: "no-cache",
+    skip: !region || region === "",
+    variables: { region, status }
+  });
+  return {
+    adsByRegion: data?.adsByRegion || [],
+    error,
+    loading,
+    refetch
+  };
+};
+
+// src/graphql/hooks/resourceActivities/hooksMutation.ts
+import { useMutation as useMutation12 } from "@apollo/client";
+
+// src/graphql/mutations/resourceActivities.ts
+import { gql as gql22 } from "@apollo/client";
+var CREATE_RESOURCE_ACTIVITY_MUTATION = gql22`
+  mutation createResourceActivity($input: ResourceActivityInputType!) {
+    createResourceActivity(input: $input) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/resourceActivities/hooksMutation.ts
+var useCreateResourceActivity = () => {
+  const [createResourceActivity, { loading, error }] = useMutation12(CREATE_RESOURCE_ACTIVITY_MUTATION);
+  return { createResourceActivity, error, loading };
+};
+
+// src/graphql/hooks/resourceActivities/hooksQuery.ts
+import { useQuery as useQuery7 } from "@apollo/client";
+
+// src/graphql/queries/resourceActivities.ts
+import { gql as gql23 } from "@apollo/client";
+var RESOURCE_ACTIVITY_FIELDS_FRAGMENT = gql23`
+  fragment ResourceActivityFields on ResourceActivityType {
+    resourceId
+    resourceType
+    activity {
+      activityType
+      location {
+        ...LocationGeoFields
+      }
+      dateStatus
+      startDate
+      startTime
+      timestamp
+      userAgent
+      userId
+    }
+  }
+  ${LOCATION_GEO_FIELDS_FRAGMENT}
+`;
+var GET_RESOURCE_ACTIVITY = gql23`
+  query getResourceActivity(
+    $resourceType: ResourceTypeEnum!
+    $resourceId: ID!
+  ) {
+    resourceActivity(resourceType: $resourceType, resourceId: $resourceId) {
+      ...ResourceActivityFields
+    }
+  }
+  ${RESOURCE_ACTIVITY_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/resourceActivities/hooksQuery.ts
+var useGetResourceActivity = (resourceId, resourceType) => {
+  const { data, loading, error, refetch } = useQuery7(GET_RESOURCE_ACTIVITY, {
+    fetchPolicy: "network-only",
+    variables: { resourceId, resourceType }
+  });
+  return {
+    error,
+    loading,
+    refetch,
+    resourceActivity: data?.resourceActivity || null
+  };
+};
+
+// src/graphql/hooks/stripe/hooksMutation.ts
+import { useMutation as useMutation13 } from "@apollo/client";
+
+// src/graphql/mutations/stripe.ts
+import { gql as gql24 } from "@apollo/client";
+var CREATE_CHECKOUT_SESSION_MUTATION = gql24`
+  mutation createCheckoutSession(
+    $planId: LicencesEnumType!
+    $billingPeriod: BillingPeriodEnumType
+  ) {
+    createCheckoutSession(planId: $planId, billingPeriod: $billingPeriod) {
+      data {
+        sessionId
+        checkoutUrl
+      }
+      message
+    }
+  }
+`;
+var CANCEL_SUBSCRIPTION_MUTATION = gql24`
+  mutation cancelSubscription {
+    cancelSubscription {
+      data
+      message
+    }
+  }
+`;
+var UPDATE_SUBSCRIPTION_PLAN_MUTATION = gql24`
+  mutation updateSubscriptionPlan(
+    $newPlanId: LicencesEnumType!
+    $billingPeriod: BillingPeriodEnumType
+  ) {
+    updateSubscriptionPlan(
+      newPlanId: $newPlanId
+      billingPeriod: $billingPeriod
+    ) {
+      data {
+        subscriptionId
+        status
+        priceId
+        currentPlan
+      }
+      message
+    }
+  }
+`;
+var CREATE_CUSTOMER_PORTAL = gql24`
+  mutation createCustomerPortal($returnUrl: String) {
+    createCustomerPortal(returnUrl: $returnUrl) {
+      data {
+        portalUrl
+      }
+      message
+    }
+  }
+`;
+var SELECT_PACKAGE_MUTATION = gql24`
+  mutation selectPackage(
+    $billingPeriod: BillingPeriodEnumType
+    $selectedLicence: LicencesEnumType!
+    $useStripe: Boolean
+  ) {
+    selectPackage(
+      billingPeriod: $billingPeriod
+      selectedLicence: $selectedLicence
+      useStripe: $useStripe
+    ) {
+      data {
+        checkoutUrl
+        licences {
+          ...LicenceFields
+        }
+        userId
+      }
+      message
+    }
+  }
+  ${LICENCE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/stripe/hooksMutation.ts
+var useCreateCheckoutSession = () => {
+  const [createCheckoutSession, { loading, error }] = useMutation13(CREATE_CHECKOUT_SESSION_MUTATION);
+  return { createCheckoutSession, error, loading };
+};
+var useCancelSubscription = () => {
+  const [cancelSubscription, { loading, error }] = useMutation13(CANCEL_SUBSCRIPTION_MUTATION);
+  return { cancelSubscription, error, loading };
+};
+var useUpdateSubscriptionPlan = () => {
+  const [updateSubscriptionPlan, { loading, error }] = useMutation13(UPDATE_SUBSCRIPTION_PLAN_MUTATION);
+  return { error, loading, updateSubscriptionPlan };
+};
+var useCreateCustomerPortal = () => {
+  const [createCustomerPortal, { loading, error }] = useMutation13(CREATE_CUSTOMER_PORTAL);
+  return { createCustomerPortal, error, loading };
+};
+var useSelectPackage = () => {
+  const [selectPackage, { loading, error }] = useMutation13(SELECT_PACKAGE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const userId = mutationResult?.data?.selectPackage?.data?.userId;
+      if (!userId) return [];
+      return [
+        { query: GET_USER, variables: { _id: userId } },
+        { query: GET_USER_EVENTS },
+        { query: GET_USER_VENDORS }
+      ];
+    }
+  });
+  return { error, loading, selectPackage };
+};
+
+// src/graphql/hooks/stripe/hooksQuery.ts
+import { useQuery as useQuery8 } from "@apollo/client";
+
+// src/graphql/queries/stripe.ts
+import { gql as gql25 } from "@apollo/client";
+var GET_SUBSCRIPTION_STATUS = gql25`
+  query getSubscriptionStatus {
+    getSubscriptionStatus {
+      subscriptionId
+      status
+      priceId
+      currentPlan
+    }
+  }
+`;
+var GET_SUBSCRIPTION_PLANS = gql25`
+  query getSubscriptionPlans {
+    getSubscriptionPlans {
+      plans {
+        name
+        description
+        licenceType
+        billingPeriod
+        stripeProductId
+        stripePriceId
+        isEligibleForDiscount
+        pricing {
+          basePrice
+          discountedPrice
+          hasDiscount
+          discountPercent
+          discountAmount
+          currency
+          formattedBasePrice
+          formattedDiscountedPrice
+        }
+      }
+      isNewUser
+      isTester
+      appliedDiscountType
+    }
+  }
+`;
+
+// src/graphql/hooks/stripe/hooksQuery.ts
+var useGetSubscriptionStatus = () => {
+  const { data, loading, error, refetch } = useQuery8(GET_SUBSCRIPTION_STATUS);
+  return {
+    data: data?.getSubscriptionStatus,
+    error,
+    loading,
+    refetch
+  };
+};
+var useGetSubscriptionPlans = () => {
+  const { data, loading, error, refetch } = useQuery8(GET_SUBSCRIPTION_PLANS);
+  return {
+    data: data?.getSubscriptionPlans,
+    error,
+    loading,
+    refetch
+  };
+};
+
+// src/graphql/hooks/partner/hooksMutation.ts
+import { useMutation as useMutation14 } from "@apollo/client";
+
+// src/graphql/mutations/partner.ts
+import { gql as gql26 } from "@apollo/client";
+var CREATE_PARTNER_MUTATION = gql26`
+  mutation createPartner($input: PartnerInputType!) {
+    createPartner(input: $input) {
+      data {
+        ...PartnerFields
+      }
+      message
+    }
+  }
+  ${PARTNER}
+`;
+var UPDATE_PARTNER_MUTATION = gql26`
+  mutation updatePartner($_id: ID!, $input: PartnerInputType!) {
+    updatePartner(_id: $_id, input: $input) {
+      data {
+        ...PartnerFields
+      }
+      message
+    }
+  }
+  ${PARTNER}
+`;
+var DELETE_PARTNER_MUTATION = gql26`
+  mutation deletePartner($_id: ID!) {
+    deletePartner(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/partner/hooksMutation.ts
+var useCreatePartner = () => {
+  const [createPartner, { loading, error }] = useMutation14(CREATE_PARTNER_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_PARTNERS }]
+  });
+  return { createPartner, error, loading };
+};
+var useUpdatePartner = () => {
+  const [updatePartner, { loading, error }] = useMutation14(UPDATE_PARTNER_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_PARTNERS }]
+  });
+  return { error, loading, updatePartner };
+};
+var useDeletePartner = () => {
+  const [deletePartner, { loading, error }] = useMutation14(DELETE_PARTNER_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_USER_PARTNERS }]
+  });
+  return { deletePartner, error, loading };
+};
+
+// src/graphql/hooks/partner/hooksQuery.ts
+import { useQuery as useQuery9 } from "@apollo/client";
+var useGetPartners = () => {
+  const { loading, error, data, refetch } = useQuery9(GET_PARTNERS, {
+    fetchPolicy: "network-only"
+  });
+  const partners = data?.partners || [];
+  return {
+    error,
+    loading,
+    partners,
+    refetch
+  };
+};
+var useGetPartner = (_id) => {
+  const { loading, error, data, refetch } = useQuery9(
+    GET_PARTNER,
+    {
+      fetchPolicy: "network-only",
+      skip: !_id || _id === "",
+      variables: { _id }
+    }
+  );
+  const partner = data?.partner;
+  return { error, loading, partner, refetch };
+};
+var useGetPartnersByRegion = (region, options) => {
+  const variables = {
+    options,
+    region
+  };
+  const { loading, error, data, refetch, fetchMore } = useQuery9(GET_PARTNERS_BY_REGION, {
+    fetchPolicy: "network-only",
+    variables
+  });
+  const partnersByRegion = data?.partnersByRegion || [];
+  return {
+    error,
+    fetchMore,
+    loading,
+    partnersByRegion,
+    refetch
+  };
+};
+var useSearchPartners = (search, region) => {
+  const { loading, error, data, refetch } = useQuery9(SEARCH_PARTNERS, {
+    fetchPolicy: "network-only",
+    skip: search.length < 3,
+    variables: { region, search }
+  });
+  const partnersSearch = data?.partnersSearch || [];
+  return { error, loading, partnersSearch, refetch };
+};
+
+// src/graphql/hooks/post/hooksMutation.ts
+import { useMutation as useMutation15 } from "@apollo/client";
+
+// src/graphql/mutations/post.ts
+import { gql as gql27 } from "@apollo/client";
+var CREATE_POST_MUTATION = gql27`
+  mutation createPost($input: PostInputType!) {
+    createPost(input: $input) {
+      data {
+        ...PostFields
+      }
+      message
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var UPDATE_POST_MUTATION = gql27`
+  mutation updatePost($_id: ID!, $input: PostInputType!) {
+    updatePost(_id: $_id, input: $input) {
+      data {
+        ...PostFields
+      }
+      message
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var DELETE_POST_MUTATION = gql27`
+  mutation deletePost($_id: ID!) {
+    deletePost(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/post/hooksMutation.ts
+var useCreatePost = () => {
+  const [createPost, { loading, error }] = useMutation15(CREATE_POST_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_POSTS }]
+  });
+  return { createPost, error, loading };
+};
+var useUpdatePost = () => {
+  const [updatePost, { loading, error }] = useMutation15(UPDATE_POST_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_POSTS }]
+  });
+  return { error, loading, updatePost };
+};
+var useDeletePost = () => {
+  const [deletePost, { loading, error }] = useMutation15(DELETE_POST_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_POSTS }]
+  });
+  return { deletePost, error, loading };
+};
+
+// src/graphql/hooks/post/hooksQuery.ts
+import { useQuery as useQuery10 } from "@apollo/client";
+var useGetPosts = () => {
+  const { data, loading, error, refetch } = useQuery10(GET_POSTS, {
+    fetchPolicy: "network-only"
+  });
+  return { error, loading, posts: data?.posts || [], refetch };
+};
+var useGetPost = (_id) => {
+  const { data, loading, error, refetch } = useQuery10(GET_POST, {
+    fetchPolicy: "network-only",
+    skip: !_id || _id === "",
+    variables: { _id }
+  });
+  return { error, loading, post: data?.post, refetch };
+};
+var useGetPostsByType = (postType) => {
+  const { data, loading, error, refetch } = useQuery10(GET_POSTS_BY_TYPE, {
+    fetchPolicy: "network-only",
+    skip: !postType,
+    variables: { postType }
+  });
+  return { error, loading, postsByType: data?.postsByType || [], refetch };
+};
+
+// src/graphql/hooks/appSettings/hooksMutation.ts
+import { useMutation as useMutation16 } from "@apollo/client";
+
+// src/graphql/mutations/appSettings.ts
+import { gql as gql28 } from "@apollo/client";
+var UPDATE_APP_SETTINGS_MUTATION = gql28`
+  mutation updateAppSettings($input: AppSettingsInputType!) {
+    updateAppSettings(input: $input) {
+      data
+      message
+    }
+  }
+`;
+var CRAWL_GOOGLE_MARKETS_MUTATION = gql28`
+  mutation crawlGoogleMarkets {
+    crawlGoogleMarkets {
+      data
+      message
+    }
+  }
+`;
+var UPDATE_GOOGLE_IMPORTED_MARKET_MUTATION = gql28`
+  mutation updateGoogleImportedMarkets {
+    updateGoogleImportedMarkets {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/queries/appSettings.ts
+import { gql as gql29 } from "@apollo/client";
+var APP_SETTINGS_FIELDS_FRAGMENT = gql29`
+  fragment AppSettingsFields on AppSettingsType {
+    _id
+    appVersion
+    createdAt
+    isOfflineMode
+    key
+    minimumRedeemableAffiliatePoints
+    updatedAt
+  }
+`;
+var GET_APP_SETTINGS = gql29`
+  query getAppSettings {
+    appSettings {
+      ...AppSettingsFields
+    }
+  }
+  ${APP_SETTINGS_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/appSettings/hooksMutation.ts
+var useUpdateAppSettings = () => {
+  const [updateAppSettings, { loading, error }] = useMutation16(UPDATE_APP_SETTINGS_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_APP_SETTINGS }]
+  });
+  return { error, loading, updateAppSettings };
+};
+var useCrawlGoogleMarkets = () => {
+  const [crawlGoogleMarkets, { loading, error }] = useMutation16(CRAWL_GOOGLE_MARKETS_MUTATION);
+  return { crawlGoogleMarkets, error, loading };
+};
+var useUpdateGoogleImportedMarkets = () => {
+  const [updateGoogleImportedMarkets, { loading, error }] = useMutation16(UPDATE_GOOGLE_IMPORTED_MARKET_MUTATION);
+  return { error, loading, updateGoogleImportedMarkets };
+};
+
+// src/graphql/hooks/appSettings/hooksQuery.ts
+import { useQuery as useQuery11 } from "@apollo/client";
+var useGetAppSettings = () => {
+  const { loading, error, data, refetch } = useQuery11(GET_APP_SETTINGS, {
+    fetchPolicy: "network-only"
+  });
+  const appSettings = data?.appSettings || null;
+  return { appSettings, error, loading, refetch };
+};
+
+// src/graphql/hooks/game/hooksMutation.ts
+import { useMutation as useMutation17 } from "@apollo/client";
+
+// src/graphql/mutations/game.ts
+import { gql as gql31 } from "@apollo/client";
+
+// src/graphql/queries/game/game.ts
+import { gql as gql30 } from "@apollo/client";
+var GAME_HISTORY_FIELDS_FRAGMENT = gql30`
+  fragment GameHistoryFields on GameHistoryType {
+    createdAt
+    gameDate {
+      ...GameDateFields
+    }
+    gameStatus
+    gameTitle
+    gameType
+    gameTypeId
+    overallGamePoints
+    pointsEarned
+  }
+  ${GAME_DATE_FIELDS_FRAGMENT}
+`;
+var GAME_DATA_FIELDS_FRAGMENT = gql30`
+  fragment GameDataFields on GameDataType {
+    dailyClue {
+      ...DailyClueGameDataFields
+    }
+    miniQuiz {
+      ...PuzzleGameDataFields
+    }
+    oddOneOut {
+      ...PuzzleGameDataFields
+    }
+  }
+  ${DAILY_CLUE_GAME_DATA_FIELDS_FRAGMENT}
+  ${PUZZLE_GAME_DATA_FIELDS_FRAGMENT}
+`;
+var GAME_FIELDS_FRAGMENT = gql30`
+  fragment GameFields on GameType {
+    _id
+    active
+    createdAt
+    gameData {
+      ...GameDataFields
+    }
+    gameHistory {
+      ...GameHistoryFields
+    }
+    gameType
+    gameTypeId
+    gameTitle
+    updatedAt
+  }
+  ${GAME_DATA_FIELDS_FRAGMENT}
+  ${GAME_HISTORY_FIELDS_FRAGMENT}
+`;
+var GAME_DOC_FIELDS_FRAGMENT = gql30`
+  fragment GameDocFields on GameDocType {
+    _id
+    active
+    createdAt
+    deletedAt
+    games {
+      ...GameFields
+    }
+    owner {
+      ...OwnerFields
+    }
+    points
+    updatedAt
+  }
+  ${OWNER_FIELDS_FRAGMENT}
+  ${GAME_FIELDS_FRAGMENT}
+`;
+var GET_GAMES = gql30`
+  query getGames {
+    games {
+      ...GameDocFields
+    }
+  }
+  ${GAME_DOC_FIELDS_FRAGMENT}
+`;
+var GET_GAME = gql30`
+  query getGame($_id: ID) {
+    game(_id: $_id) {
+      ...GameDocFields
+    }
+  }
+  ${GAME_DOC_FIELDS_FRAGMENT}
+`;
+var GET_GAME_LEADERBOARD = gql30`
+  query getGameLeaderboard {
+    gameLeaderboard {
+      gameHistory {
+        ...GameHistoryFields
+      }
+      overallPoints
+      owner {
+        ...OwnerFields
+      }
+    }
+  }
+  ${OWNER_FIELDS_FRAGMENT}
+  ${GAME_HISTORY_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/game.ts
+var START_GAME_MUTATION = gql31`
+  mutation startGame($input: BaseGameInputType!) {
+    startGame(input: $input) {
+      data {
+        ...GameDocFields
+      }
+      message
+    }
+  }
+  ${GAME_DOC_FIELDS_FRAGMENT}
+`;
+var LEAVE_GAME_MUTATION = gql31`
+  mutation leaveGame(
+    $_id: ID!
+    $gameType: GameTypeEnumType!
+    $gameTypeId: String!
+  ) {
+    leaveGame(_id: $_id, gameType: $gameType, gameTypeId: $gameTypeId) {
+      data
+      message
+    }
+  }
+`;
+var UPDATE_DAILY_CLUE_MUTATION = gql31`
+  mutation updateDailyClueGame(
+    $_id: ID!
+    $foundLetter: String!
+    $gameType: GameTypeEnumType!
+    $gameTypeId: String!
+  ) {
+    updateDailyClueGame(
+      _id: $_id
+      foundLetter: $foundLetter
+      gameType: $gameType
+      gameTypeId: $gameTypeId
+    ) {
+      data {
+        ...GameDocFields
+      }
+      message
+    }
+  }
+  ${GAME_DOC_FIELDS_FRAGMENT}
+`;
+var UPDATE_PUZZLE_GAME_MUTATION = gql31`
+  mutation updatePuzzleGame(
+    $_id: ID!
+    $answeredQuestions: [PuzzleAnsweredQuestionInputType!]!
+    $gameType: GameTypeEnumType!
+    $gameTypeId: String!
+  ) {
+    updatePuzzleGame(
+      _id: $_id
+      answeredQuestions: $answeredQuestions
+      gameType: $gameType
+      gameTypeId: $gameTypeId
+    ) {
+      data {
+        ...GameDocFields
+      }
+      message
+    }
+  }
+  ${GAME_DOC_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/game/hooksMutation.ts
+var useStartGame = () => {
+  const [startGame, { loading, error }] = useMutation17(START_GAME_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const gameId = mutationResult?.data?.startGame?.data?._id;
+      const userId = mutationResult?.data?.startGame?.data?.owner?.userId;
+      if (!gameId || !userId) return [];
+      return [
+        {
+          query: GET_GAME,
+          variables: { _id: gameId }
+          // Pass the gameId for refetching
+        },
+        {
+          query: GET_USER,
+          variables: { _id: userId }
+          // Pass the userId for refetching
+        }
+      ];
+    }
+  });
+  return { error, loading, startGame };
+};
+var useLeaveGame = () => {
+  const [leaveGame, { loading, error }] = useMutation17(LEAVE_GAME_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [
+      {
+        query: GET_GAMES
+      }
+    ]
+  });
+  return { error, leaveGame, loading };
+};
+var useUpdateDailyClueGame = () => {
+  const [updateDailyClueGame, { loading, error }] = useMutation17(UPDATE_DAILY_CLUE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const gameId = mutationResult?.data?.updateDailyClueGame?.data?._id;
+      if (!gameId) return [];
+      return [
+        {
+          query: GET_GAME,
+          variables: { _id: gameId }
+          // Pass the gameId for refetching
+        }
+      ];
+    }
+  });
+  return { error, loading, updateDailyClueGame };
+};
+var useUpdatePuzzleGame = () => {
+  const [updatePuzzleGame, { loading, error }] = useMutation17(UPDATE_PUZZLE_GAME_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const gameId = mutationResult?.data?.updatePuzzleGame?.data?._id;
+      if (!gameId) return [];
+      return [
+        {
+          query: GET_GAME,
+          variables: { _id: gameId }
+          // Pass the gameId for refetching
+        }
+      ];
+    }
+  });
+  return { error, loading, updatePuzzleGame };
+};
+
+// src/graphql/hooks/game/hooksQuery.ts
+import { useQuery as useQuery12 } from "@apollo/client";
+var useGetGames = () => {
+  const { loading, error, data, refetch } = useQuery12(GET_GAMES, {
+    fetchPolicy: "network-only"
+  });
+  const games = data?.games || [];
+  return { error, games, loading, refetch };
+};
+var useGetGame = (_id) => {
+  const { loading, error, data, refetch } = useQuery12(GET_GAME, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: _id ? { _id } : void 0
+  });
+  const game = data?.game || null;
+  return { error, game, loading, refetch };
+};
+var useGetGameLeaderboard = () => {
+  const { loading, error, data, refetch } = useQuery12(GET_GAME_LEADERBOARD, {
+    fetchPolicy: "network-only"
+  });
+  const gameLeaderboard = data?.gameLeaderboard || [];
+  return { error, gameLeaderboard, loading, refetch };
+};
+
+// src/graphql/hooks/school/hooksMutation.ts
+import { useMutation as useMutation18 } from "@apollo/client";
+
+// src/graphql/mutations/school.ts
+import { gql as gql33 } from "@apollo/client";
+
+// src/graphql/queries/school.ts
+import { gql as gql32 } from "@apollo/client";
+var SCHOOL_REGISTERED_USERS_FIELDS_FRAGMENT = gql32`
+  fragment SchoolRegisteredUsersFields on SchoolRegisteredUserType {
+    _id
+    active
+    avatar {
+      ...ResourceImageFields
+    }
+    email
+    firstName
+    lastName
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+var SCHOOL_CAMPAIGN_FIELDS_FRAGMENT = gql32`
+  fragment SchoolCampaignFields on SchoolCampaignType {
+    endDate
+    name
+    startDate
+  }
+`;
+var SCHOOL = gql32`
+  fragment SchoolFields on SchoolType {
+    _id
+    active
+    approvedAt
+    campaigns {
+      ...SchoolCampaignFields
+    }
+    contactDetails {
+      ...ContactDetailsFields
+    }
+    location {
+      ...LocationFields
+    }
+    createdAt
+    deletedAt
+    logo {
+      ...ResourceImageFields
+    }
+    name
+    owner {
+      ...OwnerFields
+    }
+    overallPoints
+    ranking
+    region
+    studentCount
+    schoolCode
+    socialMedia {
+      ...SocialMediaFields
+    }
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+    updatedAt
+  }
+  ${OWNER_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${CONTACT_DETAILS_FIELDS_FRAGMENT}
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+  ${SOCIAL_MEDIA_FIELDS_FRAGMENT}
+  ${SCHOOL_CAMPAIGN_FIELDS_FRAGMENT}
+`;
+var GET_SCHOOL = gql32`
+  query getSchool($_id: ID!) {
+    school(_id: $_id) {
+      school {
+        ...SchoolFields
+      }
+      users {
+        ...SchoolRegisteredUsersFields
+      }
+    }
+  }
+  ${SCHOOL}
+  ${SCHOOL_REGISTERED_USERS_FIELDS_FRAGMENT}
+`;
+var GET_SCHOOLS = gql32`
+  query getSchools {
+    schools {
+      ...SchoolFields
+    }
+  }
+  ${SCHOOL}
+`;
+
+// src/graphql/mutations/school.ts
+var CREATE_SCHOOL_MUTATION = gql33`
+  mutation createSchool($input: SchoolInputType!) {
+    createSchool(input: $input) {
+      data {
+        ...SchoolFields
+      }
+      message
+    }
+  }
+  ${SCHOOL}
+`;
+var UPDATE_SCHOOL_MUTATION = gql33`
+  mutation updateSchool($_id: ID!, $input: SchoolInputType!) {
+    updateSchool(_id: $_id, input: $input) {
+      data {
+        ...SchoolFields
+      }
+      message
+    }
+  }
+  ${SCHOOL}
+`;
+var DELETE_SCHOOL_MUTATION = gql33`
+  mutation deleteSchool($_id: ID!) {
+    deleteSchool(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var REQUEST_MARKETING_MATERIAL_MUTATION = gql33`
+  mutation requestMarketingMaterial(
+    $input: MarketingMaterialRequestInputType!
+  ) {
+    requestMarketingMaterial(input: $input) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/school/hooksMutation.ts
+var useCreateSchool = () => {
+  const [createSchool, { loading, error }] = useMutation18(CREATE_SCHOOL_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_SCHOOLS }]
+  });
+  return { createSchool, error, loading };
+};
+var useUpdateSchool = () => {
+  const [updateSchool, { loading, error }] = useMutation18(UPDATE_SCHOOL_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_SCHOOLS }]
+  });
+  return { error, loading, updateSchool };
+};
+var useDeleteSchool = () => {
+  const [deleteSchool, { loading, error }] = useMutation18(DELETE_SCHOOL_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_SCHOOLS }]
+  });
+  return { deleteSchool, error, loading };
+};
+var useRequestMarketingMaterial = () => {
+  const [requestMarketingMaterial, { loading, error }] = useMutation18(REQUEST_MARKETING_MATERIAL_MUTATION);
+  return { error, loading, requestMarketingMaterial };
+};
+
+// src/graphql/hooks/school/hooksQuery.ts
+import { useQuery as useQuery13 } from "@apollo/client";
+var useGetSchools = () => {
+  const { data, loading, error, refetch } = useQuery13(
+    GET_SCHOOLS,
+    {
+      fetchPolicy: "network-only"
+    }
+  );
+  return {
+    error,
+    loading,
+    refetch,
+    schools: data?.schools || []
+  };
+};
+var useGetSchool = (_id) => {
+  const { data, loading, error, refetch } = useQuery13(GET_SCHOOL, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: { _id }
+  });
+  return {
+    error,
+    loading,
+    refetch,
+    school: data?.school || null
+  };
+};
+
+// src/graphql/hooks/affiliate/hooksQuery.ts
+import { useQuery as useQuery14 } from "@apollo/client";
+
+// src/graphql/queries/affiliate.ts
+import { gql as gql34 } from "@apollo/client";
+var AFFILIATE_REWARD_FIELDS_FRAGMENT = gql34`
+  fragment AffiliateRewardFields on AffiliateRewardType {
+    createdAt
+    redeemedAt
+    rewardDescription
+    rewardType
+    rewardValue
+  }
+`;
+var AFFILIATE_RESOURCE_FIELDS_FRAGMENT = gql34`
+  fragment AffiliateResourceFields on AffiliateResourceType {
+    resourceActive
+    resourceDeletedAt
+    resourceId
+    resourceName
+    resourceOwner {
+      ...OwnerFields
+    }
+    resourceType
+    rewards {
+      ...AffiliateRewardFields
+    }
+  }
+  ${AFFILIATE_REWARD_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+`;
+var AFFILIATE_BANK_ACCOUNT_DETAILS_FIELDS_FRAGMENT = gql34`
+  fragment AffiliateBankAccountDetailsFields on AffiliateBankAccountDetailsType {
+    accountHolderName
+    accountNumber
+  }
+`;
+var AFFILIATE_DETAILS_FIELDS_FRAGMENT = gql34`
+  fragment AffiliateDetailsFields on AffiliateDetailsType {
+    bankAccountDetails {
+      ...AffiliateBankAccountDetailsFields
+    }
+    contactDetails {
+      mobilePhone
+    }
+    irdNumber
+    participantType
+    email
+    firstName
+    lastName
+    location {
+      ...LocationFields
+    }
+    socialMedia {
+      ...SocialMediaFields
+    }
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+  }
+  ${AFFILIATE_BANK_ACCOUNT_DETAILS_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${SOCIAL_MEDIA_FIELDS_FRAGMENT}
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+`;
+var AFFILIATE_FIELDS_FRAGMENT = gql34`
+  fragment AffiliateFields on AffiliateType {
+    _id
+    active
+    affiliateBonusRewards {
+      ...AffiliateRewardFields
+    }
+    affiliateCode
+    affiliateDetails {
+      ...AffiliateDetailsFields
+    }
+    affiliateResources {
+      ...AffiliateResourceFields
+    }
+    approvedAt
+    createdAt
+    deletedAt
+    redeemHistory {
+      paidAt
+      redeemedAt
+      rewardValue
+    }
+    overallPoints
+    owner {
+      ...OwnerFields
+    }
+    updatedAt
+  }
+  ${AFFILIATE_DETAILS_FIELDS_FRAGMENT}
+  ${AFFILIATE_RESOURCE_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+`;
+var GET_AFFILIATE = gql34`
+  query getAffiliate($_id: ID!) {
+    affiliate(_id: $_id) {
+      ...AffiliateFields
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+var GET_AFFILIATES = gql34`
+  query getAffiliates {
+    affiliates {
+      ...AffiliateFields
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/affiliate/hooksQuery.ts
+var useGetAffiliate = (_id) => {
+  const { data, loading, error, refetch } = useQuery14(GET_AFFILIATE, {
+    fetchPolicy: "network-only",
+    skip: !_id || _id === "",
+    variables: { _id }
+  });
+  const affiliate = data?.affiliate;
+  return {
+    affiliate,
+    error,
+    loading,
+    refetch
+  };
+};
+var useGetAffiliates = () => {
+  const { data, loading, error, refetch } = useQuery14(GET_AFFILIATES, {
+    fetchPolicy: "network-only"
+  });
+  const affiliates = data?.affiliates || [];
+  return {
+    affiliates,
+    error,
+    loading,
+    refetch
+  };
+};
+
+// src/graphql/hooks/affiliate/hooksMutation.ts
+import { useMutation as useMutation19 } from "@apollo/client";
+
+// src/graphql/mutations/affiliate.ts
+import { gql as gql35 } from "@apollo/client";
+var UPDATE_AFFILIATE_DETAILS_MUTATION = gql35`
+  mutation updateAffiliateDetails(
+    $input: AffiliateDetailsInputType!
+    $affiliateId: ID!
+  ) {
+    updateAffiliateDetails(input: $input, affiliateId: $affiliateId) {
+      data {
+        ...AffiliateFields
+      }
+      message
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+var DELETE_AFFILIATE_MUTATION = gql35`
+  mutation deleteAffiliate($_id: ID!) {
+    deleteAffiliate(_id: $_id) {
+      data
+      message
+    }
+  }
+`;
+var REDEEM_AFFILIATE_REWARD_MUTATION = gql35`
+  mutation redeemAffiliateReward($affiliateId: ID!) {
+    redeemAffiliateReward(affiliateId: $affiliateId) {
+      data {
+        ...AffiliateFields
+      }
+      message
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+var ASSIGN_AFFILIATE_RESOURCE_REWARD_MUTATION = gql35`
+  mutation assignAffiliateResourceReward(
+    $affiliateId: ID!
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+    $rewardType: AffiliateRewardEnumType!
+  ) {
+    assignAffiliateResourceReward(
+      affiliateId: $affiliateId
+      resourceId: $resourceId
+      resourceType: $resourceType
+      rewardType: $rewardType
+    ) {
+      data {
+        ...AffiliateFields
+      }
+      message
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+var ASSIGN_AFFILIATE_BONUS_REWARD_MUTATION = gql35`
+  mutation assignAffiliateBonusReward(
+    $affiliateId: ID!
+    $rewardType: AffiliateRewardEnumType!
+  ) {
+    assignAffiliateBonusReward(
+      affiliateId: $affiliateId
+      rewardType: $rewardType
+    ) {
+      data {
+        ...AffiliateFields
+      }
+      message
+    }
+  }
+  ${AFFILIATE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/affiliate/hooksMutation.ts
+var useUpdateAffiliateDetails = () => {
+  const [updateAffiliateDetails, { loading, error }] = useMutation19(UPDATE_AFFILIATE_DETAILS_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const affiliateId = mutationResult?.data?.updateAffiliateDetails?.data?._id;
+      if (!affiliateId) return [];
+      return [{ query: GET_AFFILIATE, variables: { _id: affiliateId } }];
+    }
+  });
+  return { error, loading, updateAffiliateDetails };
+};
+var useDeleteAffiliate = () => {
+  const [deleteAffiliate, { loading, error }] = useMutation19(DELETE_AFFILIATE_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: [{ query: GET_AFFILIATES }]
+  });
+  return { deleteAffiliate, error, loading };
+};
+var useRedeemAffiliateReward = () => {
+  const [redeemAffiliateReward, { loading, error }] = useMutation19(REDEEM_AFFILIATE_REWARD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const affiliateId = mutationResult?.data?.redeemAffiliateReward?.data?._id;
+      if (!affiliateId) return [];
+      return [{ query: GET_AFFILIATE, variables: { _id: affiliateId } }];
+    }
+  });
+  return { error, loading, redeemAffiliateReward };
+};
+var useAssignAffiliateResourceReward = () => {
+  const [assignAffiliateResourceReward, { loading, error }] = useMutation19(ASSIGN_AFFILIATE_RESOURCE_REWARD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const affiliateId = mutationResult?.data?.assignAffiliateResourceReward?.data?._id;
+      if (!affiliateId) return [];
+      return [{ query: GET_AFFILIATE, variables: { _id: affiliateId } }];
+    }
+  });
+  return { assignAffiliateResourceReward, error, loading };
+};
+var useAssignAffiliateBonusReward = () => {
+  const [assignAffiliateBonusReward, { loading, error }] = useMutation19(ASSIGN_AFFILIATE_BONUS_REWARD_MUTATION, {
+    awaitRefetchQueries: true,
+    refetchQueries: (mutationResult) => {
+      const affiliateId = mutationResult?.data?.assignAffiliateBonusReward?.data?._id;
+      if (!affiliateId) return [];
+      return [{ query: GET_AFFILIATE, variables: { _id: affiliateId } }];
+    }
+  });
+  return { assignAffiliateBonusReward, error, loading };
+};
+
+export {
+  GET_POST,
+  GET_EVENT_BY_SLUG,
+  GET_VENDOR_BY_SLUG,
+  GET_PARTNER_BY_SLUG,
+  GET_POST_BY_SLUG,
+  GET_RESOURCE_CONNECTIONS,
+  toGraphqlQueryString,
+  useAdminUpdateResourceType,
+  useAdminResendUserVerificationEmail,
+  useAdminPermanentlyDeleteResource,
+  useCreatePrivateChat,
+  useSendChatMessage,
+  useDeleteChat,
+  useAddParticipantToChat,
+  useRemoveParticipantFromChat,
+  useToggleChatMessageLike,
+  useMarkChatMessagesSeen,
+  useReportChatUser,
+  useGetChat,
+  useGetUserChats,
+  useGetChatSubscription,
+  useGetChatsByRegion,
+  useGetReportedChatUsers,
+  useContactUs,
+  useCreateEvent,
+  useUpdateEvent,
+  useDeleteEvent,
+  useCreateEventInfo,
+  useUpdateEventInfo,
+  useGetEvents,
+  useGetEvent,
+  useGetEventByPlaceId,
+  useGetEventsByRegion,
+  useSearchEvents,
+  useGetEventsNearMe,
+  useGetEventInfo,
+  useCreateBulkNotifications,
+  useMarkNotificationRead,
+  useMarkAllNotificationsRead,
+  useDeleteNotification,
+  useDeleteAllNotifications,
+  useGetUserNotifications,
+  useGetNotificationCount,
+  useGetUserNotificationsSubscription,
+  useGetNotificationCountSubscription,
+  useCreatePoster,
+  useCreatePushToken,
+  useCreateRelation,
+  useUpdateRelation,
+  useDeleteRelation,
+  useGetRelation,
+  useGetRelationByEventAndVendor,
+  useGetEventRelations,
+  useGetVendorRelations,
+  useGetResourceConnections,
+  useCreateVendor,
+  useUpdateVendor,
+  useDeleteVendor,
+  useCreateVendorInfo,
+  useUpdateVendorInfo,
+  useCreateUnregisteredVendor,
+  useUpdateUnregisteredVendor,
+  useDeleteUnregisteredVendor,
+  useUnlinkUnregisteredVendorByInviterId,
+  useGetVendors,
+  useGetVendor,
+  useGetVendorsByRegion,
+  useSearchVendors,
+  useGetVendorInfo,
+  useGetUnregisteredVendors,
+  useGetUnregisteredVendorsByInviterId,
+  useGetUnregisteredVendor,
+  useCreateUser,
+  useUpdateUser,
+  useDeleteUser,
+  useRedeemReward,
+  useAddUserFavouriteResource,
+  useRemoveUserFavouriteResource,
+  useAddUserInterestResource,
+  useRemoveUserInterestResource,
+  useAddUserGoingResource,
+  useRemoveUserGoingResource,
+  useAddUserPresentResource,
+  useRemoveUserPresentResource,
+  useSelectStandardPackage,
+  useCreateAd,
+  useUpdateAd,
+  useDeleteAd,
+  useGetAds,
+  useGetAd,
+  useGetAdsByRegion,
+  useCreateResourceActivity,
+  useGetResourceActivity,
+  useCreateCheckoutSession,
+  useCancelSubscription,
+  useUpdateSubscriptionPlan,
+  useCreateCustomerPortal,
+  useSelectPackage,
+  useGetSubscriptionStatus,
+  useGetSubscriptionPlans,
+  useCreatePartner,
+  useUpdatePartner,
+  useDeletePartner,
+  useGetPartners,
+  useGetPartner,
+  useGetPartnersByRegion,
+  useSearchPartners,
+  useCreatePost,
+  useUpdatePost,
+  useDeletePost,
+  useGetPosts,
+  useGetPost,
+  useGetPostsByType,
+  useUpdateAppSettings,
+  useCrawlGoogleMarkets,
+  useUpdateGoogleImportedMarkets,
+  useGetAppSettings,
+  useStartGame,
+  useLeaveGame,
+  useUpdateDailyClueGame,
+  useUpdatePuzzleGame,
+  useGetGames,
+  useGetGame,
+  useGetGameLeaderboard,
+  useCreateSchool,
+  useUpdateSchool,
+  useDeleteSchool,
+  useRequestMarketingMaterial,
+  useGetSchools,
+  useGetSchool,
+  useGetAffiliate,
+  useGetAffiliates,
+  useUpdateAffiliateDetails,
+  useDeleteAffiliate,
+  useRedeemAffiliateReward,
+  useAssignAffiliateResourceReward,
+  useAssignAffiliateBonusReward
+};
+//# sourceMappingURL=chunk-R6PCFOYO.mjs.map