@connectedxm/client 1.3.19 → 1.4.1

package/dist/index.mjs

@@ -326,6 +326,13 @@ var ContentGuestType = /* @__PURE__ */ ((ContentGuestType2) => {
   ContentGuestType2["author"] = "author";
   return ContentGuestType2;
 })(ContentGuestType || {});
+var LeadStatus = /* @__PURE__ */ ((LeadStatus2) => {
+  LeadStatus2["new"] = "new";
+  LeadStatus2["favorited"] = "favorited";
+  LeadStatus2["archived"] = "archived";
+  LeadStatus2["deleted"] = "deleted";
+  return LeadStatus2;
+})(LeadStatus || {});
 var isTypeLead = (lead) => {
   return lead.email !== void 0;
 };
@@ -472,6 +479,7 @@ var ERR_FEATURE_NOT_AVAILABLE = 456;
 var ERR_TIER_REQUIRED = 457;
 var ERR_SUBSCRIPTION_REQUIRED = 458;
 var ERR_INTEGRATION_PERMISSION_DENIED = 459;
+var ERR_KNOWN_ERROR = 460;
 var CUSTOM_ERROR_CODES = [
   ERR_NOT_GROUP_MEMBER,
   ERR_NOT_EVENT_REGISTERED,
@@ -479,7 +487,8 @@ var CUSTOM_ERROR_CODES = [
   ERR_FEATURE_NOT_AVAILABLE,
   ERR_TIER_REQUIRED,
   ERR_SUBSCRIPTION_REQUIRED,
-  ERR_INTEGRATION_PERMISSION_DENIED
+  ERR_INTEGRATION_PERMISSION_DENIED,
+  ERR_KNOWN_ERROR
 ];
 var GetErrorMessage = (error, fallback = "Something went wrong") => {
   let message = fallback;
@@ -2780,41 +2789,6 @@ var useGetEventSponsors = (eventId = "", params = {}, options = {}) => {
   );
 };
 
-// src/queries/events/useGetEventPassTypes.ts
-var EVENT_PASS_TYPES_QUERY_KEY = (eventId, passTypeId = "") => [...EVENT_QUERY_KEY(eventId), "PASS_TYPES", passTypeId];
-var SET_EVENT_PASS_TYPES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_PASS_TYPES_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetEventPassTypes = async ({
-  eventId,
-  passTypeId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/tickets`, {
-    params: {
-      ticketId: passTypeId || void 0
-    }
-  });
-  return data;
-};
-var useGetEventPassTypes = (eventId = "", passTypeId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    EVENT_PASS_TYPES_QUERY_KEY(eventId, passTypeId),
-    (params) => GetEventPassTypes({ eventId, passTypeId, ...params }),
-    {
-      ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
-    }
-  );
-};
-
 // src/queries/events/useGetFeaturedEvents.ts
 var EVENTS_FEATURED_QUERY_KEY = () => [
   ...EVENTS_QUERY_KEY(),
@@ -2864,39 +2838,6 @@ var useGetFeaturedEvents = (params = {}, options = {}) => {
   );
 };
 
-// src/queries/events/useGetEventPassType.ts
-var EVENT_PASS_TYPE_QUERY_KEY = (eventId, passTypeId) => [...EVENT_PASS_TYPES_QUERY_KEY(eventId), passTypeId];
-var SET_EVENT_PASS_TYPE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_PASS_TYPE_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetEventPassType = async ({
-  eventId,
-  passTypeId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/events/${eventId}/tickets/${passTypeId}`
-  );
-  return data;
-};
-var useGetEventPassType = (eventId = "", passTypeId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_PASS_TYPE_QUERY_KEY(eventId, passTypeId),
-    (params) => GetEventPassType({ eventId, passTypeId, ...params }),
-    {
-      ...options,
-      enabled: !!eventId && !!passTypeId && (options?.enabled ?? true)
-    }
-  );
-};
-
 // src/queries/groups/useGetAllGroupEvents.ts
 var ALL_GROUP_EVENTS = (past) => [
   ...EVENTS_QUERY_KEY(past),
@@ -4306,6 +4247,148 @@ var useGetSelf = (ignoreExecuteAs, options = {}) => {
   );
 };
 
+// src/queries/self/addresses/useGetSelfAddresses.ts
+var SELF_ADDRESSES_QUERY_KEY = () => [
+  ...SELF_QUERY_KEY(),
+  "ADDRESSES"
+];
+var GetSelfAddresses = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/addresses`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (activityId) => SELF_ADDRESS_QUERY_KEY(activityId),
+      locale
+    );
+  }
+  return data;
+};
+var useGetSelfAddresses = (params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_ADDRESSES_QUERY_KEY(),
+    (params2) => GetSelfAddresses({ ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/addresses/useGetSelfAddress.ts
+var SELF_ADDRESS_QUERY_KEY = (addressId) => {
+  const keys = [...SELF_ADDRESSES_QUERY_KEY(), addressId];
+  return keys;
+};
+var GetSelfAddress = async ({
+  addressId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/addresses/${addressId}`);
+  return data;
+};
+var useGetSelfAddress = (addressId = "", options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedSingleQuery(
+    SELF_ADDRESS_QUERY_KEY(addressId),
+    (params) => GetSelfAddress({ addressId, ...params }),
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/leads/useGetSelfLeads.ts
+var SELF_LEADS_QUERY_KEY = () => [
+  ...SELF_QUERY_KEY(),
+  "LEADS"
+];
+var GetSelfLeads = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/leads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (activityId) => SELF_LEAD_QUERY_KEY(activityId),
+      locale
+    );
+  }
+  return data;
+};
+var useGetSelfLeads = (params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_LEADS_QUERY_KEY(),
+    (params2) => GetSelfLeads({ ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/leads/useGetSelfLead.ts
+var SELF_LEAD_QUERY_KEY = (leadId) => {
+  const keys = [...SELF_LEADS_QUERY_KEY(), leadId];
+  return keys;
+};
+var GetSelfLead = async ({
+  leadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/leads/${leadId}`);
+  return data;
+};
+var useGetSelfLead = (leadId = "", options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedSingleQuery(
+    SELF_LEAD_QUERY_KEY(leadId),
+    (params) => GetSelfLead({ leadId, ...params }),
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
 // src/queries/self/chat/useGetSelfChatChannels.ts
 var SELF_CHAT_CHANNELS_QUERY_KEY = () => [
   ...SELF_QUERY_KEY(),
@@ -4513,7 +4596,7 @@ var useGetSelfChatChannelMessages = (channelId = "", params = {}, options = {})
 };
 
 // src/queries/self/registration/useGetSelfEventRegistration.ts
-var SELF_EVENT_REGISTRATION_QUERY_KEY = (eventId) => [...SELF_QUERY_KEY(), "EVENT_REGISTRATION", eventId];
+var SELF_EVENT_REGISTRATION_QUERY_KEY = (eventId) => [...SELF_QUERY_KEY(), "REGISTRATION", eventId];
 var SET_SELF_EVENT_REGISTRATION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
@@ -4541,628 +4624,645 @@ var useGetSelfEventRegistration = (eventId, options = {}) => {
     }),
     {
       ...options,
+      staleTime: Infinity,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
       enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationIntent.ts
-var SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY = (eventId, registrationId) => [...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId), registrationId, "INTENT"];
-var GetSelfEventRegistrationIntent = async ({
+// src/queries/self/registration/useGetSelfEventRegistrationPassTypes.ts
+var SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_KEY = (eventId, passTypeId = "") => [...EVENT_QUERY_KEY(eventId), "PASS_TYPES", passTypeId];
+var SET_SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetSelfEventRegistrationPassTypes = async ({
   eventId,
-  registrationId,
+  passTypeId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/cart/intent`
-  );
+  const { data } = await clientApi.get(`/events/${eventId}/passTypes`, {
+    params: {
+      ticketId: passTypeId || void 0
+    }
+  });
   return data;
 };
-var useGetSelfEventRegistrationIntent = (eventId, registrationId = "", options = {}) => {
-  const { authenticated } = useConnectedXM();
+var useGetSelfEventRegistrationPassTypes = (eventId = "", passTypeId = "", options = {}) => {
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId, registrationId),
-    (params) => GetSelfEventRegistrationIntent({ eventId, registrationId, ...params }),
+    SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_KEY(eventId, passTypeId),
+    (params) => GetSelfEventRegistrationPassTypes({ eventId, passTypeId, ...params }),
     {
-      staleTime: Infinity,
-      retry: false,
-      retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && (options?.enabled ?? true)
+      enabled: !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPayment.ts
-var SELF_EVENT_REGISTRATION_PAYMENT_QUERY_KEY = (eventId, paymentId) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  "PAYMENT",
-  paymentId
-];
-var SET_SELF_EVENT_REGISTRATION_PAYMENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/self/registration/useGetSelfEventRegistrationAddOns.ts
+var SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_KEY = (eventId) => [...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId), "ADD_ONS"];
+var SET_SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_REGISTRATION_PAYMENT_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventRegistrationPayment = async ({
+var GetSelfEventRegistrationAddOns = async ({
   eventId,
-  registrationId,
-  paymentId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/payments/${paymentId}`,
+    `/self/events/${eventId}/registration/addOns`,
     {}
   );
   return data;
 };
-var useGetSelfEventRegistrationPayment = (eventId, registrationId, paymentId, options = {}) => {
+var useGetSelfEventRegistrationAddOns = (eventId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PAYMENT_QUERY_KEY(eventId, paymentId),
-    (params) => GetSelfEventRegistrationPayment({
+    SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_KEY(eventId),
+    (params) => GetSelfEventRegistrationAddOns({
       eventId,
-      registrationId,
-      paymentId,
       ...params
     }),
     {
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!paymentId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPurchase.ts
-var SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY = (eventId, registrationId, purchaseId) => [
-  ...SELF_QUERY_KEY(),
-  "EVENT",
-  eventId,
-  "REGISTRATION",
-  registrationId,
-  "PURCHASE",
-  purchaseId
-];
-var SET_SELF_EVENT_REGISTRATION_PURCHASE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/self/registration/useGetSelfEventRegistrationRoomTypes.ts
+var SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY = (eventId) => [...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId), "ROOM_TYPES"];
+var SET_SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventRegistrationPurchase = async ({
+var GetSelfEventRegistrationRoomTypes = async ({
   eventId,
-  registrationId,
-  purchaseId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}`,
+    `/self/events/${eventId}/registration/roomTypes`,
     {}
   );
   return data;
 };
-var useGetSelfEventRegistrationPurchase = (eventId, registrationId, purchaseId, options = {}) => {
+var useGetSelfEventRegistrationRoomTypes = (eventId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(
-      eventId,
-      registrationId,
-      purchaseId
-    ),
-    (params) => GetSelfEventRegistrationPurchase({
+    SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY(eventId),
+    (params) => GetSelfEventRegistrationRoomTypes({
       eventId,
-      registrationId,
-      purchaseId,
       ...params
     }),
     {
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!purchaseId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPurchaseSections.ts
-var SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY = (eventId, registrationId, purchaseId) => [
-  ...SELF_QUERY_KEY(),
-  "EVENT",
-  eventId,
-  "REGISTRATION",
-  registrationId,
-  "PURCHASE",
-  purchaseId,
-  "SECTIONS"
-];
-var SET_SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/self/registration/useGetSelfEventRegistrationQuestions.ts
+var SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY = (eventId) => [...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId), "QUESTIONS"];
+var SET_SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventRegistrationPurchaseSections = async ({
+var GetSelfEventRegistrationQuestions = async ({
   eventId,
-  registrationId,
-  purchaseId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}`,
+    `/self/events/${eventId}/registration/questions`,
     {}
   );
   return data;
 };
-var useGetSelfEventRegistrationPurchaseSections = (eventId, registrationId, purchaseId, options = {}) => {
+var useGetSelfEventRegistrationQuestions = (eventId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
-      eventId,
-      registrationId,
-      purchaseId
-    ),
-    (params) => GetSelfEventRegistrationPurchaseSections({
+    SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY(eventId),
+    (params) => GetSelfEventRegistrationQuestions({
       eventId,
-      registrationId,
-      purchaseId,
       ...params
     }),
     {
-      retry: false,
-      staleTime: Infinity,
-      refetchOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!purchaseId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPurchaseAddOns.ts
-var SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_KEY = (eventId, registrationId, purchaseId) => [
-  ...SELF_QUERY_KEY(),
-  "EVENT",
-  eventId,
-  "REGISTRATION",
-  registrationId,
-  "PURCHASE",
-  purchaseId,
-  "ADD_ONS"
+// src/queries/self/registration/useGetSelfEventTicketCouponIntent.ts
+var SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY = (eventId, ticketId, quantity, addressId) => [
+  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
+  "COUPON_INTENT",
+  ticketId,
+  quantity,
+  addressId
 ];
-var SET_SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetSelfEventRegistrationPurchaseAddOns = async ({
+var GetSelfEventTicketCouponIntent = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  ticketId,
+  quantity,
+  addressId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/addOns`,
-    {}
+    `/self/events/${eventId}/registration/coupons/intent`,
+    {
+      params: {
+        ticketId,
+        quantity,
+        addressId
+      }
+    }
   );
   return data;
 };
-var useGetSelfEventRegistrationPurchaseAddOns = (eventId, registrationId, purchaseId, options = {}) => {
+var useGetSelfEventTicketCouponIntent = (eventId = "", ticketId = "", quantity = 0, addressId = "", options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_KEY(
+    SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY(
       eventId,
-      registrationId,
-      purchaseId
+      ticketId,
+      quantity,
+      addressId
     ),
-    (params) => GetSelfEventRegistrationPurchaseAddOns({
+    (params) => GetSelfEventTicketCouponIntent({
       eventId,
-      registrationId,
-      purchaseId,
+      ticketId,
+      quantity,
+      addressId,
       ...params
     }),
     {
+      staleTime: Infinity,
+      retry: false,
+      retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!purchaseId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!ticketId && !!quantity && !!addressId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPurchaseReservationSections.ts
-var SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_KEY = (eventId, registrationId, purchaseId) => [
-  ...SELF_QUERY_KEY(),
-  "EVENT",
-  eventId,
-  "REGISTRATION",
-  registrationId,
-  "PURCHASE",
-  purchaseId,
-  "RESERVATIONS"
-];
-var SET_SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_KEY(
-        ...keyParams
-      ),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
+// src/queries/self/registration/useGetSelfEventRegistrationIntent.ts
+var SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY = (eventId, addressId) => {
+  const key = [...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId), "INTENT"];
+  if (addressId) {
+    key.push(addressId);
+  }
+  return key;
 };
-var GetSelfEventRegistrationPurchaseReservationSections = async ({
+var GetSelfEventRegistrationIntent = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  addressId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/reservationSections`,
-    {}
+    `/self/events/${eventId}/registration/intent`,
+    {
+      params: {
+        addressId
+      }
+    }
   );
   return data;
 };
-var useGetSelfEventRegistrationPurchaseReservationSections = (eventId, registrationId, purchaseId, options = {}) => {
+var useGetSelfEventRegistrationIntent = (eventId = "", addressId = "", options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_KEY(
-      eventId,
-      registrationId,
-      purchaseId
-    ),
-    (params) => GetSelfEventRegistrationPurchaseReservationSections({
-      eventId,
-      registrationId,
-      purchaseId,
-      ...params
-    }),
+    SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId, addressId),
+    (params) => GetSelfEventRegistrationIntent({ eventId, addressId, ...params }),
     {
+      staleTime: Infinity,
+      retry: false,
+      retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!purchaseId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!addressId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationPurchaseAddOnsIntent.ts
-var SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_INTENT_QUERY_KEY = (eventId, registrationId, purchaseId, addOnIds) => {
-  const key = [
-    ...SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(
-      eventId,
-      registrationId,
-      purchaseId
-    ),
-    "ADD_ONS_INTENT"
-  ];
-  if (addOnIds) {
-    key.push(...addOnIds);
+// src/queries/self/subscriptions/useGetSelfSubscriptions.ts
+var SELF_SUBSCRIPTIONS_QUERY_KEY = (status) => {
+  const key = [...SELF_QUERY_KEY(), "SUBSCRIPTIONS"];
+  if (status) {
+    key.push(status);
   }
   return key;
 };
-var GetSelfEventRegistrationPurchaseAddOnsIntent = async ({
-  eventId,
-  registrationId,
-  purchaseId,
-  addOnIds,
-  clientApiParams
+var GetSelfSubscriptions = async ({
+  status,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}/addOns/intent`,
+  const { data } = await clientApi.get(`/self/subscriptions`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      status: status || void 0
+    }
+  });
+  if (queryClient) {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (subscriptionId) => SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId),
+      locale
+    );
+  }
+  return data;
+};
+var useGetSelfSubscriptions = (status, params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_SUBSCRIPTIONS_QUERY_KEY(status),
+    (params2) => GetSelfSubscriptions({ status, ...params2 }),
+    params,
     {
-      params: {
-        addOnIds: addOnIds ? addOnIds.join(",") : ""
-      }
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
     }
   );
+};
+
+// src/queries/self/subscriptions/useGetSelfSubscription.ts
+var SELF_SUBSCRIPTION_QUERY_KEY = (subscriptionId) => [...SELF_SUBSCRIPTIONS_QUERY_KEY(), subscriptionId];
+var GetSelfSubcription = async ({
+  subscriptionId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/subscriptions/${subscriptionId}`);
   return data;
 };
-var useGetSelfEventRegistrationPurchaseAddOnsIntent = (eventId, registrationId, purchaseId, addOnIds, options = {}) => {
+var useGetSelfSubcription = (subscriptionId = "", options = {}) => {
   const { authenticated } = useConnectedXM();
-  return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_INTENT_QUERY_KEY(
-      eventId,
-      registrationId,
-      purchaseId,
-      addOnIds
-    ),
-    (params) => GetSelfEventRegistrationPurchaseAddOnsIntent({
-      eventId,
-      registrationId,
-      purchaseId,
-      addOnIds,
-      ...params
-    }),
+  return useConnectedSingleQuery(
+    SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId),
+    (params) => GetSelfSubcription({ subscriptionId, ...params }),
     {
-      staleTime: Infinity,
-      retry: false,
-      retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!purchaseId && !!addOnIds && (options?.enabled ?? true)
+      enabled: !!authenticated && !!subscriptionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventTicketCouponIntent.ts
-var SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY = (eventId, registrationId, ticketId, quantity) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  registrationId,
-  "COUPON_INTENT",
-  ticketId,
-  quantity
-];
-var GetSelfEventTicketCouponIntent = async ({
-  eventId,
-  registrationId,
-  ticketId,
-  quantity,
+// src/queries/self/subscriptions/useGetSelfSubscriptionPayments.ts
+var SELF_SUBSCRIPTION_PAYMENTS_QUERY_KEY = (subscriptionId) => [...SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId), "PAYMENTS"];
+var GetSelfSubscriptionPayments = async ({
+  subscriptionId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/coupons/intent`,
+    `/self/subscriptions/${subscriptionId}/payments`,
     {
       params: {
-        ticketId,
-        quantity
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
       }
     }
   );
   return data;
 };
-var useGetSelfEventTicketCouponIntent = (eventId = "", registrationId = "", ticketId = "", quantity = 0, options = {}) => {
+var useGetSelfSubscriptionPayments = (subscriptionId, params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_SUBSCRIPTION_PAYMENTS_QUERY_KEY(subscriptionId),
+    (params2) => GetSelfSubscriptionPayments({ ...params2, subscriptionId }),
+    params,
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/attendee/useGetSelfEventAttendee.ts
+var SELF_EVENT_ATTENDEE_QUERY_KEY = (eventId) => [
+  ...SELF_QUERY_KEY(),
+  "ATTENDEE",
+  eventId
+];
+var SET_SELF_EVENT_ATTENDEE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...SELF_EVENT_ATTENDEE_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetSelfEventAttendee = async ({
+  eventId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/events/${eventId}/attendee`);
+  return data;
+};
+var useGetSelfEventAttendee = (eventId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY(
-      eventId,
-      registrationId,
-      ticketId,
-      quantity
-    ),
-    (params) => GetSelfEventTicketCouponIntent({
+    SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
+    (params) => GetSelfEventAttendee({
       eventId,
-      registrationId,
-      ticketId,
-      quantity,
       ...params
     }),
     {
-      staleTime: Infinity,
-      retry: false,
-      retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!ticketId && !!quantity && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationCoupons.ts
-var SELF_EVENT_REGISTRATION_COUPONS_QUERY_KEY = (eventId, registrationId) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  registrationId,
-  "COUPONS"
+// src/queries/self/attendee/useGetSelfEventAttendeePayment.ts
+var SELF_EVENT_ATTENDEE_PAYMENT_QUERY_KEY = (eventId, paymentId) => [
+  ...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
+  "PAYMENT",
+  paymentId
 ];
-var GetSelfEventRegistrationCoupons = async ({
+var SET_SELF_EVENT_ATTENDEE_PAYMENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...SELF_EVENT_ATTENDEE_PAYMENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetSelfEventAttendeePayment = async ({
   eventId,
-  registrationId,
-  clientApiParams,
-  queryClient,
-  locale
+  paymentId,
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/coupons`,
+    `/self/events/${eventId}/attendee/payments/${paymentId}`,
     {}
   );
-  if (queryClient && data.status === "ok") {
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (couponId) => SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(
-        eventId,
-        registrationId,
-        couponId
-      ),
-      locale
-    );
-  }
   return data;
 };
-var useGetSelfEventRegistrationCoupons = (eventId, registrationId, params = {}, options = {}) => {
+var useGetSelfEventAttendeePayment = (eventId, paymentId, options = {}) => {
   const { authenticated } = useConnectedXM();
-  return useConnectedInfiniteQuery(
-    SELF_EVENT_REGISTRATION_COUPONS_QUERY_KEY(eventId, registrationId),
-    (params2) => GetSelfEventRegistrationCoupons({
+  return useConnectedSingleQuery_default(
+    SELF_EVENT_ATTENDEE_PAYMENT_QUERY_KEY(eventId, paymentId),
+    (params) => GetSelfEventAttendeePayment({
       eventId,
-      registrationId,
-      ...params2
+      paymentId,
+      ...params
     }),
-    params,
     {
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!paymentId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationCoupon.ts
-var SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY = (eventId, registrationId, couponId) => [
-  ...SELF_EVENT_REGISTRATION_COUPONS_QUERY_KEY(eventId, registrationId),
-  couponId
-];
-var SET_SELF_EVENT_REGISTRATION_COUPON_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/self/attendee/useGetSelfEventAttendeePass.ts
+var SELF_EVENT_ATTENDEE_PASS_QUERY_KEY = (eventId, passId) => [...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId), "PASS", passId];
+var SET_SELF_EVENT_ATTENDEE_PASS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_ATTENDEE_PASS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventRegistrationCoupon = async ({
+var GetSelfEventAttendeePass = async ({
   eventId,
-  registrationId,
-  couponId,
+  passId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/coupons/${couponId}`,
-    {}
+    `/self/events/${eventId}/attendee/passs/${passId}`
   );
   return data;
 };
-var useGetSelfEventRegistrationCoupon = (eventId = "", registrationId = "", couponId = "", options = {}) => {
+var useGetSelfEventAttendeePass = (eventId, passId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(eventId, registrationId, couponId),
-    (params) => GetSelfEventRegistrationCoupon({
+    SELF_EVENT_ATTENDEE_PASS_QUERY_KEY(eventId, passId),
+    (params) => GetSelfEventAttendeePass({
       eventId,
-      registrationId,
-      couponId,
+      passId,
       ...params
     }),
     {
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!couponId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!passId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventRegistrationCouponPurchases.ts
-var SELF_EVENT_REGISTRATION_COUPON_REGISTRATIONS_QUERY_KEY = (eventId, registrationId, couponId) => [
-  ...SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(
-    eventId,
-    registrationId,
-    couponId
-  ),
-  "PURCHASES"
-];
-var GetSelfEventRegistrationCouponPurchases = async ({
+// src/queries/self/attendee/useGetSelfEventAttendeePassAddOnsIntent.ts
+var SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_INTENT_QUERY_KEY = (eventId, passId, addressId, addOnIds) => {
+  const key = [
+    ...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
+    passId,
+    "ADD_ONS_INTENT"
+  ];
+  if (addOnIds) {
+    key.push(...addOnIds);
+  }
+  key.push(addressId);
+  return key;
+};
+var GetSelfEventAttendeePassAddOnsIntent = async ({
   eventId,
-  registrationId,
-  couponId,
+  passId,
+  addOnIds,
+  addressId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/${registrationId}/coupons/${couponId}/purchases`,
-    {}
+    `/self/events/${eventId}/attendee/passes/${passId}/addOns/intent`,
+    {
+      params: {
+        addOnIds: addOnIds ? addOnIds.join(",") : "",
+        addressId
+      }
+    }
   );
   return data;
 };
-var useGetSelfEventRegistrationCouponPurchases = (eventId = "", registrationId = "", couponId = "", params = {}, options = {}) => {
+var useGetSelfEventAttendeePassAddOnsIntent = (eventId, passId, addressId, addOnIds, options = {}) => {
   const { authenticated } = useConnectedXM();
-  return useConnectedInfiniteQuery(
-    SELF_EVENT_REGISTRATION_COUPON_REGISTRATIONS_QUERY_KEY(
+  return useConnectedSingleQuery_default(
+    SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_INTENT_QUERY_KEY(
       eventId,
-      registrationId,
-      couponId
+      passId,
+      addressId,
+      addOnIds
     ),
-    (params2) => GetSelfEventRegistrationCouponPurchases({
+    (params) => GetSelfEventAttendeePassAddOnsIntent({
+      eventId,
+      passId,
+      addressId,
+      addOnIds,
+      ...params
+    }),
+    {
+      staleTime: Infinity,
+      retry: false,
+      retryOnMount: false,
+      ...options,
+      enabled: !!authenticated && !!eventId && !!passId && !!addressId && !!addOnIds && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/attendee/useGetSelfEventAttendeeCoupons.ts
+var SELF_EVENT_ATTENDEE_COUPONS_QUERY_KEY = (eventId) => [...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId), "COUPONS"];
+var GetSelfEventAttendeeCoupons = async ({
+  eventId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/self/events/${eventId}/attendee/coupons`,
+    {}
+  );
+  return data;
+};
+var useGetSelfEventAttendeeCoupons = (eventId, params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_EVENT_ATTENDEE_COUPONS_QUERY_KEY(eventId),
+    (params2) => GetSelfEventAttendeeCoupons({
       eventId,
-      registrationId,
-      couponId,
       ...params2
     }),
     params,
     {
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!couponId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventPasses.ts
-var SELF_EVENT_PASSES_QUERY_KEY = (eventId) => {
-  const key = [...SELF_QUERY_KEY(), "EVENT_PASSES", eventId];
-  return key;
-};
-var SET_SELF_EVENT_PASSES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/self/attendee/useGetSelfEventAttendeeCoupon.ts
+var SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY = (eventId, couponId) => [SELF_EVENT_ATTENDEE_COUPONS_QUERY_KEY(eventId), couponId];
+var SET_SELF_EVENT_REGISTRATION_COUPON_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_PASSES_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventPasses = async ({
+var GetSelfEventAttendeeCoupon = async ({
   eventId,
+  couponId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/events/${eventId}/passes`, {});
+  const { data } = await clientApi.get(
+    `/self/events/${eventId}/attendee/coupons/${couponId}`,
+    {}
+  );
   return data;
 };
-var useGetSelfEventPasses = (eventId, options = {}) => {
+var useGetSelfEventAttendeeCoupon = (eventId = "", couponId = "", options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_PASSES_QUERY_KEY(eventId),
-    (params) => GetSelfEventPasses({
+    SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(eventId, couponId),
+    (params) => GetSelfEventAttendeeCoupon({
       eventId,
+      couponId,
       ...params
     }),
     {
       ...options,
-      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!couponId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventCoupons.ts
-var SELF_EVENT_COUPONS_QUERY_KEY = (eventId) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  "COUPONS"
+// src/queries/self/attendee/useGetSelfEventAttendeeCouponPasses.ts
+var SELF_EVENT_ATTENDEE_COUPON_PASSES_QUERY_KEY = (eventId, couponId) => [
+  ...SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY(eventId, couponId),
+  "PASSES"
 ];
-var GetSelfEventCoupons = async ({
+var GetSelfEventAttendeeCouponPasses = async ({
   eventId,
+  couponId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/registration/coupons`,
+    `/self/events/${eventId}/attendee/coupons/${couponId}/passes`,
     {}
   );
   return data;
 };
-var useGetSelfEventCoupons = (eventId, params = {}, options = {}) => {
+var useGetSelfEventAttendeeCouponPasses = (eventId = "", couponId = "", params = {}, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedInfiniteQuery(
-    SELF_EVENT_COUPONS_QUERY_KEY(eventId),
-    (params2) => GetSelfEventCoupons({
+    SELF_EVENT_ATTENDEE_COUPON_PASSES_QUERY_KEY(eventId, couponId),
+    (params2) => GetSelfEventAttendeeCouponPasses({
       eventId,
+      couponId,
       ...params2
     }),
     params,
     {
       ...options,
-      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!couponId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventTransfersLogs.ts
-var EVENT_TRANSFER_LOGS_QUERY_KEY = (eventId) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  "TRANSFERS"
-];
-var GetSelfEventTransfersLogs = async ({
+// src/queries/self/attendee/useGetSelfEventAttendeeTransfersLogs.ts
+var SELF_EVENT_ATTENDEE_TRANSFER_LOGS_QUERY_KEY = (eventId) => [...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId), "TRANSFERS"];
+var GetSelfEventAttendeeTransfersLogs = async ({
   pageParam,
   pageSize,
   orderBy,
@@ -5172,107 +5272,163 @@ var GetSelfEventTransfersLogs = async ({
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/self/events/${eventId}/transfers/logs`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
+    `/self/events/${eventId}/attendee/transfers/logs`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetSelfEventAttendeeTransfersLogs = (eventId, params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_EVENT_ATTENDEE_TRANSFER_LOGS_QUERY_KEY(eventId),
+    (params2) => GetSelfEventAttendeeTransfersLogs({
+      ...params2,
+      eventId
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/self/attendee/useGetSelfEventAttendeePassQuestionSections.ts
+var SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY = (eventId, passId) => [
+  ...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
+  "PASSES",
+  passId,
+  "QUESTIONS"
+];
+var SET_SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetSelfEventAttendeePassQuestionSections = async ({
+  eventId,
+  passId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/self/events/${eventId}/attendee/passs/${passId}/questions`,
+    {}
   );
   return data;
 };
-var useGetSelfEventTransfersLogs = (eventId, params = {}, options = {}) => {
+var useGetSelfEventAttendeePassQuestionSections = (eventId, passId, options = {}) => {
   const { authenticated } = useConnectedXM();
-  return useConnectedInfiniteQuery(
-    EVENT_TRANSFER_LOGS_QUERY_KEY(eventId),
-    (params2) => GetSelfEventTransfersLogs({
-      ...params2,
-      eventId
+  return useConnectedSingleQuery_default(
+    SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(eventId, passId),
+    (params) => GetSelfEventAttendeePassQuestionSections({
+      eventId,
+      passId,
+      ...params
     }),
-    params,
     {
+      retry: false,
+      staleTime: Infinity,
+      refetchOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!passId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/useGetSelfEventAttendee.ts
-var SELF_EVENT_ATTENDEE_QUERY_KEY = (eventId) => [
-  ...SELF_QUERY_KEY(),
-  "EVENT_ATTENDEE",
-  eventId
+// src/queries/self/attendee/useGetSelfEventAttendeePassAddOns.ts
+var SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_KEY = (eventId, passId) => [
+  ...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
+  "PASSES",
+  passId,
+  "AVAILABLE_ADD_ONS"
 ];
-var SET_SELF_EVENT_ATTENDEE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SELF_EVENT_ATTENDEE_QUERY_KEY(...keyParams),
+      ...SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventAttendee = async ({
+var GetSelfEventAttendeePassAddOns = async ({
   eventId,
+  passId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/events/${eventId}/attendee`);
+  const { data } = await clientApi.get(
+    `/self/events/${eventId}/attendee/passes/${passId}/addOns`,
+    {}
+  );
   return data;
 };
-var useGetSelfEventAttendee = (eventId, options = {}) => {
+var useGetSelfEventAttendeePassAddOns = (eventId, passId, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
-    (params) => GetSelfEventAttendee({
+    SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_KEY(eventId, passId),
+    (params) => GetSelfEventAttendeePassAddOns({
       eventId,
+      passId,
       ...params
     }),
     {
       ...options,
-      enabled: !!authenticated && !!eventId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!passId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/self/registration/sessions/useGetSelfEventRegistrationSessionPassesIntent.ts
-var SELF_EVENT_REGISTRATION_SESSION_PASSES_INTENT_QUERY_KEY = (eventId, registrationId, sessionId, sessionPassIds) => [
-  ...SELF_EVENT_REGISTRATION_QUERY_KEY(eventId),
-  registrationId,
+// src/queries/self/attendee/sessions/useGetSelfEventRegistrationSessionPassesIntent.ts
+var SELF_EVENT_ATTENDEE_SESSION_PASSES_INTENT_QUERY_KEY = (eventId, sessionId, addressId, sessionPassIds) => [
+  ...SELF_EVENT_ATTENDEE_QUERY_KEY(eventId),
   sessionId,
-  ...sessionPassIds,
-  "SESSION_PASSES_INTENT"
+  addressId,
+  "SESSION_PASSES_INTENT",
+  ...sessionPassIds
 ];
-var GetSelfEventRegistrationSessionPassesIntent = async ({
+var GetSelfEventAttendeeSessionPassesIntent = async ({
   eventId,
-  registrationId,
   sessionId,
+  addressId,
   sessionPasses,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/sessions/${sessionId}/intent`,
-    sessionPasses
+    `/self/events/${eventId}/attendee/sessions/${sessionId}/intent`,
+    {
+      addressId,
+      sessionPasses
+    }
   );
   return data;
 };
-var useGetSelfEventRegistrationSessionPassesIntent = (eventId, registrationId, sessionId, sessionPasses, options = {}) => {
+var useGetSelfEventAttendeeSessionPassesIntent = (eventId, sessionId, addressId, sessionPasses, options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_EVENT_REGISTRATION_SESSION_PASSES_INTENT_QUERY_KEY(
+    SELF_EVENT_ATTENDEE_SESSION_PASSES_INTENT_QUERY_KEY(
       eventId,
-      registrationId,
       sessionId,
+      addressId,
       sessionPasses.map(({ passId }) => passId)
     ),
-    (params) => GetSelfEventRegistrationSessionPassesIntent({
+    (params) => GetSelfEventAttendeeSessionPassesIntent({
       eventId,
-      registrationId,
       sessionId,
+      addressId,
       sessionPasses,
       ...params
     }),
@@ -5281,117 +5437,7 @@ var useGetSelfEventRegistrationSessionPassesIntent = (eventId, registrationId, s
       retry: false,
       retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!eventId && !!registrationId && !!sessionId && !!sessionPasses && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/subscriptions/useGetSelfSubscriptions.ts
-var SELF_SUBSCRIPTIONS_QUERY_KEY = (status) => {
-  const key = [...SELF_QUERY_KEY(), "SUBSCRIPTIONS"];
-  if (status) {
-    key.push(status);
-  }
-  return key;
-};
-var GetSelfSubscriptions = async ({
-  status,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  queryClient,
-  clientApiParams,
-  locale
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/subscriptions`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0,
-      status: status || void 0
-    }
-  });
-  if (queryClient) {
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (subscriptionId) => SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId),
-      locale
-    );
-  }
-  return data;
-};
-var useGetSelfSubscriptions = (status, params = {}, options = {}) => {
-  const { authenticated } = useConnectedXM();
-  return useConnectedInfiniteQuery(
-    SELF_SUBSCRIPTIONS_QUERY_KEY(status),
-    (params2) => GetSelfSubscriptions({ status, ...params2 }),
-    params,
-    {
-      ...options,
-      enabled: !!authenticated && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/subscriptions/useGetSelfSubscription.ts
-var SELF_SUBSCRIPTION_QUERY_KEY = (subscriptionId) => [...SELF_SUBSCRIPTIONS_QUERY_KEY(), subscriptionId];
-var GetSelfSubcription = async ({
-  subscriptionId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/subscriptions/${subscriptionId}`);
-  return data;
-};
-var useGetSelfSubcription = (subscriptionId = "", options = {}) => {
-  const { authenticated } = useConnectedXM();
-  return useConnectedSingleQuery(
-    SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId),
-    (params) => GetSelfSubcription({ subscriptionId, ...params }),
-    {
-      ...options,
-      enabled: !!authenticated && !!subscriptionId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/subscriptions/useGetSelfSubscriptionPayments.ts
-var SELF_SUBSCRIPTION_PAYMENTS_QUERY_KEY = (subscriptionId) => [...SELF_SUBSCRIPTION_QUERY_KEY(subscriptionId), "PAYMENTS"];
-var GetSelfSubscriptionPayments = async ({
-  subscriptionId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/self/subscriptions/${subscriptionId}/payments`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
-  );
-  return data;
-};
-var useGetSelfSubscriptionPayments = (subscriptionId, params = {}, options = {}) => {
-  const { authenticated } = useConnectedXM();
-  return useConnectedInfiniteQuery(
-    SELF_SUBSCRIPTION_PAYMENTS_QUERY_KEY(subscriptionId),
-    (params2) => GetSelfSubscriptionPayments({ ...params2, subscriptionId }),
-    params,
-    {
-      ...options,
-      enabled: !!authenticated && (options?.enabled ?? true)
+      enabled: !!authenticated && !!eventId && !!sessionId && !!addressId && !!sessionPasses && (options?.enabled ?? true)
     }
   );
 };
@@ -6391,29 +6437,31 @@ var useGetInvoice = (invoiceId = "", options = {}) => {
 };
 
 // src/queries/invoices/useGetInvoiceIntent.ts
-var SELF_INVOICE_INTENT_QUERY_KEY = (invoiceId) => [
-  ...INVOICE_QUERY_KEY(invoiceId),
-  "INTENT"
-];
+var SELF_INVOICE_INTENT_QUERY_KEY = (invoiceId, addressId) => [...INVOICE_QUERY_KEY(invoiceId), addressId, "INTENT"];
 var GetInvoiceIntent = async ({
   invoiceId,
+  addressId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/invoices/${invoiceId}/intent`);
+  const { data } = await clientApi.get(`/invoices/${invoiceId}/intent`, {
+    params: {
+      addressId
+    }
+  });
   return data;
 };
-var useGetInvoiceIntent = (invoiceId, options = {}) => {
+var useGetInvoiceIntent = (invoiceId = "", addressId = "", options = {}) => {
   const { authenticated } = useConnectedXM();
   return useConnectedSingleQuery_default(
-    SELF_INVOICE_INTENT_QUERY_KEY(invoiceId),
-    (params) => GetInvoiceIntent({ invoiceId, ...params }),
+    SELF_INVOICE_INTENT_QUERY_KEY(invoiceId, addressId),
+    (params) => GetInvoiceIntent({ invoiceId, addressId, ...params }),
     {
       staleTime: Infinity,
       retry: false,
       retryOnMount: false,
       ...options,
-      enabled: !!authenticated && !!invoiceId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!invoiceId && !!addressId && (options?.enabled ?? true)
     }
   );
 };
@@ -6635,9 +6683,9 @@ var useGetSelfEventListingQuestions = (eventId, params = {}, options = {}) => {
   );
 };
 
-// src/queries/listings/useGetListingRegistrations.ts
-var LISTING_REGISTRATIONS_QUERY_KEY = (eventId, status) => [...LISTING_QUERY_KEY(eventId), "REGISTRATIONS", status ?? "ALL"];
-var GetSelfEventListingRegistrations = async ({
+// src/queries/listings/useGetListingAttendees.ts
+var LISTING_ATTENDEES_QUERY_KEY = (eventId, status) => [...LISTING_QUERY_KEY(eventId), "ATTENDEES", status ?? "ALL"];
+var GetSelfEventListingAttendees = async ({
   eventId,
   pageParam,
   pageSize,
@@ -6647,7 +6695,7 @@ var GetSelfEventListingRegistrations = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/listings/${eventId}/registrations`, {
+  const { data } = await clientApi.get(`/listings/${eventId}/attendees`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -6660,8 +6708,8 @@ var GetSelfEventListingRegistrations = async ({
 };
 var useGetSelfEventListingsRegistrations = (eventId, status, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    LISTING_REGISTRATIONS_QUERY_KEY(eventId, status),
-    (params2) => GetSelfEventListingRegistrations({ eventId, status, ...params2 }),
+    LISTING_ATTENDEES_QUERY_KEY(eventId, status),
+    (params2) => GetSelfEventListingAttendees({ eventId, status, ...params2 }),
     params,
     {
       ...options,
@@ -6670,12 +6718,12 @@ var useGetSelfEventListingsRegistrations = (eventId, status, params = {}, option
   );
 };
 
-// src/queries/listings/useGetListingRegistration.ts
-var LISTING_REGISTRATION_QUERY_KEY = (eventId, registrationId) => [...LISTING_REGISTRATIONS_QUERY_KEY(eventId), registrationId];
-var SET_LISTING_REGISTRATION_QUERY_KEY = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/listings/useGetListingAttendee.ts
+var LISTING_ATTENDEE_QUERY_KEY = (eventId, accountId) => [...LISTING_ATTENDEES_QUERY_KEY(eventId), accountId];
+var SET_LISTING_ATTENDEE_QUERY_KEY = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...LISTING_REGISTRATION_QUERY_KEY(...keyParams),
+      ...LISTING_ATTENDEE_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
@@ -6683,33 +6731,33 @@ var SET_LISTING_REGISTRATION_QUERY_KEY = (client, keyParams, response, baseKeys
 };
 var GetSelfEventListingRegistration = async ({
   eventId,
-  registrationId,
+  accountId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/listings/${eventId}/registrations/${registrationId}`
+    `/listings/${eventId}/attendees/${accountId}`
   );
   return data;
 };
-var useGetSelfEventListingRegistration = (eventId = "", registrationId = "", options = {}) => {
+var useGetSelfEventListingRegistration = (eventId = "", accountId = "", options = {}) => {
   return useConnectedSingleQuery(
-    LISTING_REGISTRATION_QUERY_KEY(eventId, registrationId),
-    (params) => GetSelfEventListingRegistration({ eventId, registrationId, ...params }),
+    LISTING_ATTENDEE_QUERY_KEY(eventId, accountId),
+    (params) => GetSelfEventListingRegistration({ eventId, accountId, ...params }),
     {
       ...options,
-      enabled: !!eventId && !!registrationId
+      enabled: !!eventId && !!accountId
     }
   );
 };
 
-// src/queries/listings/useGetListingPurchases.ts
-var LISTING_PURCHASES_QUERY_KEY = (eventId, checkedIn) => [
+// src/queries/listings/useGetListingPasses.ts
+var LISTING_PASSES_QUERY_KEY = (eventId, checkedIn) => [
   ...LISTING_QUERY_KEY(eventId),
   "PURCHASES",
   typeof checkedIn !== "undefined" ? checkedIn : "ALL"
 ];
-var GetSelfEventListingPurchases = async ({
+var GetSelfEventListingPasses = async ({
   eventId,
   checkedIn,
   pageParam,
@@ -6719,7 +6767,7 @@ var GetSelfEventListingPurchases = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/listings/${eventId}/purchases`, {
+  const { data } = await clientApi.get(`/listings/${eventId}/passes`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -6730,10 +6778,10 @@ var GetSelfEventListingPurchases = async ({
   });
   return data;
 };
-var useGetSelfEventListingPurchases = (eventId, checkedIn, params = {}, options = {}) => {
+var useGetSelfEventListingPasses = (eventId, checkedIn, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    LISTING_PURCHASES_QUERY_KEY(eventId, checkedIn),
-    (params2) => GetSelfEventListingPurchases({ eventId, checkedIn, ...params2 }),
+    LISTING_PASSES_QUERY_KEY(eventId, checkedIn),
+    (params2) => GetSelfEventListingPasses({ eventId, checkedIn, ...params2 }),
     params,
     {
       ...options,
@@ -6742,35 +6790,33 @@ var useGetSelfEventListingPurchases = (eventId, checkedIn, params = {}, options
   );
 };
 
-// src/queries/listings/useGetListingPurchase.ts
-var LISTING_PURCHASE_QUERY_KEY = (eventId, purchaseId) => [...LISTING_PURCHASES_QUERY_KEY(eventId), purchaseId];
-var SET_LISTING_PURCHASE_QUERY_KEY = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/listings/useGetListingPass.ts
+var LISTING_PASS_QUERY_KEY = (eventId, passId) => [...LISTING_PASSES_QUERY_KEY(eventId), passId];
+var SET_LISTING_PASS_QUERY_KEY = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...LISTING_PURCHASE_QUERY_KEY(...keyParams),
+      ...LISTING_PASS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetSelfEventListingPurchase = async ({
+var GetSelfEventListingPass = async ({
   eventId,
-  purchaseId,
+  passId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/listings/${eventId}/purchases/${purchaseId}`
-  );
+  const { data } = await clientApi.get(`/listings/${eventId}/passes/${passId}`);
   return data;
 };
-var useGetSelfEventListingPurchase = (eventId = "", purchaseId = "", options = {}) => {
+var useGetSelfEventListingPass = (eventId = "", passId = "", options = {}) => {
   return useConnectedSingleQuery(
-    LISTING_PURCHASE_QUERY_KEY(eventId, purchaseId),
-    (params) => GetSelfEventListingPurchase({ eventId, purchaseId, ...params }),
+    LISTING_PASS_QUERY_KEY(eventId, passId),
+    (params) => GetSelfEventListingPass({ eventId, passId, ...params }),
     {
       ...options,
-      enabled: !!eventId && !!purchaseId
+      enabled: !!eventId && !!passId
     }
   );
 };
@@ -6835,51 +6881,51 @@ var useGetSelfEventListingReport = (eventId, options = {}) => {
   );
 };
 
-// src/queries/listings/useGetListingRegistrationPurchaseSections.ts
-var LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY = (eventId, registrationId, purchaseId) => [
-  ...LISTING_REGISTRATION_QUERY_KEY(eventId, registrationId),
-  purchaseId,
+// src/queries/listings/useGetListingAttendeePassSectionQuestions.ts
+var LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY = (eventId, accountId, passId) => [
+  ...LISTING_ATTENDEE_QUERY_KEY(eventId, accountId),
+  passId,
   "SECTIONS"
 ];
-var SET_LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(...keyParams),
+      ...LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetListingRegistrationPurchaseSections = async ({
+var GetListingAttendeePassQuestionSections = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  accountId,
+  passId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/listings/${eventId}/registrations/${registrationId}/purchases/${purchaseId}`,
+    `/listings/${eventId}/attendees/${accountId}/passes/${passId}`,
     {}
   );
   return data;
 };
-var useGetListingRegistrationPurchaseSections = (eventId, registrationId, purchaseId, options = {}) => {
+var useGetListingAttendeePassQuestionSections = (eventId, accountId, passId, options = {}) => {
   return useConnectedSingleQuery_default(
-    LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
+    LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(
       eventId,
-      registrationId,
-      purchaseId
+      accountId,
+      passId
     ),
-    (params) => GetListingRegistrationPurchaseSections({
+    (params) => GetListingAttendeePassQuestionSections({
       eventId,
-      registrationId,
-      purchaseId,
+      accountId,
+      passId,
       ...params
     }),
     {
       retry: false,
       ...options,
-      enabled: !!eventId && !!registrationId && !!purchaseId && (options?.enabled ?? true)
+      enabled: !!eventId && !!accountId && !!passId && (options?.enabled ?? true)
     }
   );
 };
@@ -8417,73 +8463,177 @@ var CompleteEventActivation = async ({
   }
   return data;
 };
-var useCompleteEventActivation = (options = {}) => {
-  return useConnectedMutation_default(CompleteEventActivation, options);
+var useCompleteEventActivation = (options = {}) => {
+  return useConnectedMutation_default(CompleteEventActivation, options);
+};
+
+// src/mutations/organization/useCapturePaymentIntent.ts
+var CapturePaymentIntent = async ({
+  intent,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/organization/intents/${intent.id}/capture`
+  );
+  if (queryClient && data.status === "ok") {
+    if (intent.eventId) {
+      queryClient.removeQueries({
+        queryKey: ["SELF", "REGISTRATION"],
+        exact: false
+      });
+      queryClient.invalidateQueries({
+        queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(intent.eventId)
+      });
+      ADD_SELF_RELATIONSHIP(
+        queryClient,
+        [clientApiParams.locale],
+        "events",
+        intent.eventId
+      );
+    }
+    if (intent.invoiceId) {
+      queryClient.invalidateQueries({
+        queryKey: INVOICE_QUERY_KEY(intent.invoiceId)
+      });
+    }
+  }
+  return data;
+};
+var useCapturePaymentIntent = (options = {}) => {
+  return useConnectedMutation_default(CapturePaymentIntent, options);
+};
+
+// src/mutations/self/addresses/useCreateSelfAddress.ts
+var CreateSelfAddress = async ({
+  address,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/self/addresses`,
+    address
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: SELF_ADDRESSES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useCreateSelfAddress = (options = {}) => {
+  return useConnectedMutation_default(CreateSelfAddress, options);
+};
+
+// src/mutations/self/addresses/useDeleteSelfAddress.ts
+var DeleteSelfAddress = async ({
+  addressId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/self/addresses/${addressId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: SELF_ADDRESSES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useDeleteSelfAddress = (options = {}) => {
+  return useConnectedMutation_default(DeleteSelfAddress, options);
+};
+
+// src/mutations/self/addresses/useUpdateSelfAddress.ts
+var UpdateSelfAddress = async ({
+  addressId,
+  address,
+  queryClient,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.put(
+    `/self/addresses/${addressId}`,
+    address
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({ queryKey: SELF_ADDRESSES_QUERY_KEY() });
+    queryClient.invalidateQueries({
+      queryKey: SELF_ADDRESS_QUERY_KEY(addressId)
+    });
+  }
+  return data;
+};
+var useUpdateSelfAddress = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfAddress, options);
+};
+
+// src/mutations/self/leads/useCreateSelfLead.ts
+var CreateSelfLead = async ({
+  passId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/self/leads/${passId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.setQueryData(SELF_LEAD_QUERY_KEY(data.data.id), data.data);
+  }
+  return data;
+};
+var useCreateSelfLead = (options = {}) => {
+  return useConnectedMutation(CreateSelfLead, options);
 };
 
-// src/mutations/events/useCreateEventLead.ts
-var CreateEventLead = async ({
-  eventId,
-  purchaseId,
-  note,
+// src/mutations/self/leads/useDeleteSelfLead.ts
+var DeleteSelfLead = async ({
+  leadId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/events/${eventId}/leads/${purchaseId}`,
-    {
-      note: note || void 0
-    }
+  const { data } = await clientApi.delete(
+    `/self/leads/${leadId}`
   );
   if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: SELF_LEADS_QUERY_KEY()
+    });
   }
   return data;
 };
-var useCreateEventLead = (options = {}) => {
-  return useConnectedMutation(CreateEventLead, options);
+var useDeleteSelfLead = (options = {}) => {
+  return useConnectedMutation_default(DeleteSelfLead, options);
 };
 
-// src/mutations/organization/useCapturePaymentIntent.ts
-var CapturePaymentIntent = async ({
-  intent,
-  clientApiParams,
-  queryClient
+// src/mutations/self/leads/useUpdateSelfLead.ts
+var UpdateSelfLead = async ({
+  leadId,
+  lead,
+  queryClient,
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/organization/intents/${intent.id}/capture`
+  const { data } = await clientApi.put(
+    `/self/leads/${leadId}`,
+    lead
   );
   if (queryClient && data.status === "ok") {
-    if (intent.eventId && intent.registrationId) {
-      queryClient.invalidateQueries({
-        predicate: ({ queryKey }) => {
-          if (queryKey[0] === "SELF" && (queryKey[1] === "EVENT_REGISTRATION" || queryKey[1] === "EVENT_ATTENDEE") || queryKey[0] === "SELF" && queryKey[1] === "EVENT" && queryKey[3] === "REGISTRATION") {
-            return true;
-          }
-          return false;
-        }
-      });
-      queryClient.invalidateQueries({
-        queryKey: SELF_EVENT_PASSES_QUERY_KEY(intent.eventId)
-      });
-      ADD_SELF_RELATIONSHIP(
-        queryClient,
-        [clientApiParams.locale],
-        "events",
-        intent.eventId
-      );
-    }
-    if (intent.invoiceId) {
-      queryClient.invalidateQueries({
-        queryKey: INVOICE_QUERY_KEY(intent.invoiceId)
-      });
-    }
+    queryClient.invalidateQueries({ queryKey: SELF_LEADS_QUERY_KEY() });
+    queryClient.invalidateQueries({
+      queryKey: SELF_LEAD_QUERY_KEY(leadId)
+    });
   }
   return data;
 };
-var useCapturePaymentIntent = (options = {}) => {
-  return useConnectedMutation_default(CapturePaymentIntent, options);
+var useUpdateSelfLead = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfLead, options);
 };
 
 // src/mutations/self/chat/useAddSelfChatChannelMember.ts
@@ -8650,17 +8800,16 @@ var useUpdateSelfChatChannelNotifications = (options = {}) => {
   return useConnectedMutation_default(UpdateSelfChatChannelNotifications, options);
 };
 
-// src/mutations/self/events/registration/cart/useApplySelfEventRegistrationCoupon.ts
+// src/mutations/self/events/registration/useApplySelfEventRegistrationCoupon.ts
 var SelectSelfEventRegistrationCoupon = async ({
   eventId,
-  registrationId,
   couponId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/cart/coupon`,
+    `/self/events/${eventId}/registration/coupon`,
     {
       couponId
     }
@@ -8670,10 +8819,8 @@ var SelectSelfEventRegistrationCoupon = async ({
       clientApiParams.locale
     ]);
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
     queryClient.invalidateQueries({
       queryKey: SELF_EVENTS_QUERY_KEY(false)
@@ -8694,23 +8841,20 @@ var useSelectSelfEventRegistrationCoupon = (options = {}) => {
   return useConnectedMutation_default(SelectSelfEventRegistrationCoupon, options);
 };
 
-// src/mutations/self/events/registration/cart/useRemoveSelfEventRegistrationCoupon.ts
+// src/mutations/self/events/registration/useRemoveSelfEventRegistrationCoupon.ts
 var RemoveSelfEventRegistrationCoupon = async ({
   eventId,
-  registrationId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.delete(
-    `/self/events/${eventId}/registration/${registrationId}/cart/coupons`
+    `/self/events/${eventId}/registration/coupons`
   );
   if (queryClient && data.status === "ok") {
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
     SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
       clientApiParams.locale
@@ -8734,350 +8878,163 @@ var useRemoveSelfEventRegistrationCoupon = (options = {}) => {
   return useConnectedMutation_default(RemoveSelfEventRegistrationCoupon, options);
 };
 
-// src/mutations/self/events/registration/cart/useRemoveSelfEventRegistrationPurchase.ts
-var RemoveSelfEventRegistrationPurchase = async ({
+// src/mutations/self/events/registration/useUpdateSelfEventRegistrationPasses.ts
+var UpdateSelfEventRegistrationPasses = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  passes,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}`
+  const { data } = await clientApi.post(
+    `/self/events/${eventId}/registration/passes`,
+    passes
   );
   if (queryClient && data.status === "ok") {
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_KEY(eventId)
     });
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
-  }
-  return data;
-};
-var useRemoveSelfEventRegistrationPurchase = (options = {}) => {
-  return useConnectedMutation_default(RemoveSelfEventRegistrationPurchase, options);
-};
-
-// src/mutations/self/events/registration/cart/useAddSelfEventRegistrationPurchase.ts
-var AddSelfEventRegistrationPurchase = async ({
-  eventId,
-  registrationId,
-  ticketId,
-  quantity,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases`,
-    {
-      ticketId,
-      quantity
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY(eventId)
     });
-    queryClient.invalidateQueries({ queryKey: SELF_EVENTS_QUERY_KEY(false) });
-    queryClient.invalidateQueries({ queryKey: SELF_EVENTS_QUERY_KEY(true) });
-    queryClient.invalidateQueries({ queryKey: EVENT_QUERY_KEY(eventId) });
-    queryClient.invalidateQueries({
-      queryKey: EVENT_REGISTRANTS_QUERY_KEY(eventId)
+    queryClient.removeQueries({
+      queryKey: SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY(eventId)
+    });
+    queryClient.removeQueries({
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
   }
   return data;
 };
-var useAddSelfEventRegistrationPurchase = (options = {}) => {
-  return useConnectedMutation_default(AddSelfEventRegistrationPurchase, options);
+var useUpdateSelfEventRegistrationPasses = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfEventRegistrationPasses, options);
 };
 
-// src/mutations/self/events/registration/cart/useSubmitSelfEventRegistration.ts
-var SubmitSelfEventRegistration = async ({
+// src/mutations/self/events/registration/useUpdateSelfEventRegistrationAddOns.ts
+var UpdateSelfEventRegistrationPurchaseAddOn = async ({
   eventId,
-  registrationId,
-  payment,
+  passes,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/cart/submit`,
-    payment
+    `/self/events/${eventId}/registration/addOns`,
+    passes
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_PASSES_QUERY_KEY(eventId)
-    });
-    SET_SELF_EVENT_ATTENDEE_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
-    });
-    ADD_SELF_RELATIONSHIP(
-      queryClient,
-      [clientApiParams.locale],
-      "events",
-      eventId
-    );
-  }
-  return data;
-};
-var useSubmitSelfEventRegistration = (options = {}) => {
-  return useConnectedMutation_default(SubmitSelfEventRegistration, options);
-};
-
-// src/mutations/self/events/registration/cart/useUpdateSelfEventRegistrationPurchaseQuestionResponse.ts
-import { produce as produce4 } from "immer";
-var UpdateSelfEventRegistrationQuestionResponse = async ({
-  eventId,
-  registrationId,
-  purchaseId,
-  questionId,
-  value,
-  update,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  let data;
-  if (update) {
-    const response2 = await clientApi.put(
-      `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}/questions/${questionId}`,
-      {
-        value
-      }
-    );
-    data = response2.data;
-  } else {
-    const response2 = await clientApi.put(
-      `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/questions/${questionId}`,
-      {
-        value
-      }
-    );
-    data = response2.data;
-  }
-  const response = {
-    ...data,
-    data: data.data[0]
-  };
-  if (queryClient && data.status === "ok") {
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], response, [
-      clientApiParams.locale
-    ]);
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
+    queryClient.removeQueries({
+      queryKey: SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY(eventId)
     });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
+    queryClient.removeQueries({
+      queryKey: SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY(eventId)
     });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
+    queryClient.removeQueries({
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
-    queryClient.setQueryData(
-      [
-        ...SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
-          eventId,
-          registrationId,
-          purchaseId
-        ),
-        ...GetBaseSingleQueryKeys(clientApiParams.locale)
-      ],
-      (oldData) => {
-        if (oldData.data) {
-          return produce4(oldData, (draft) => {
-            draft.data.forEach((section) => {
-              section.questions.forEach((question) => {
-                const fillQuestionResponse = (question2, questionId2, value2) => {
-                  if (question2.id === questionId2) {
-                    question2.response = value2;
-                  }
-                  if (question2.choices.length > 0) {
-                    question2.choices.forEach((choice) => {
-                      if (choice.subQuestions.length > 0) {
-                        choice.subQuestions.forEach((subQuestion) => {
-                          if (isRegistrationQuestion(subQuestion)) {
-                            fillQuestionResponse(
-                              subQuestion,
-                              questionId2,
-                              data.data[1]
-                            );
-                          }
-                        });
-                      }
-                    });
-                  }
-                };
-                fillQuestionResponse(question, questionId, data.data[1]);
-              });
-            });
-          });
-        }
-        return oldData;
-      }
-    );
   }
-  return response;
+  return data;
 };
-var useUpdateSelfEventRegistrationQuestionResponse = (update, options = {}) => {
-  return useConnectedMutation_default(
-    (params) => UpdateSelfEventRegistrationQuestionResponse({ update, ...params }),
-    options
-  );
+var useUpdateSelfEventRegistrationPurchaseAddOn = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfEventRegistrationPurchaseAddOn, options);
 };
 
-// src/mutations/self/events/registration/cart/useAddSelfEventRegistrationPurchaseAddOn.ts
-var AddSelfEventRegistrationPurchaseAddOn = async ({
+// src/mutations/self/events/registration/useUpdateSelfEventRegistrationReservations.ts
+var UpdateSelfEventRegistrationReservations = async ({
   eventId,
-  registrationId,
-  purchaseId,
-  addOnId,
+  passes,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/addOns/${addOnId}`
+    `/self/events/${eventId}/registration/reservations`,
+    passes
   );
   if (queryClient && data.status === "ok") {
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY(eventId)
     });
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
-    });
-    queryClient.invalidateQueries({ queryKey: SELF_EVENTS_QUERY_KEY(false) });
-    queryClient.invalidateQueries({ queryKey: SELF_EVENTS_QUERY_KEY(true) });
-    queryClient.invalidateQueries({ queryKey: EVENT_QUERY_KEY(eventId) });
-    queryClient.invalidateQueries({
-      queryKey: EVENT_REGISTRANTS_QUERY_KEY(eventId)
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
   }
   return data;
 };
-var useAddSelfEventRegistrationPurchaseAddOn = (options = {}) => {
-  return useConnectedMutation_default(AddSelfEventRegistrationPurchaseAddOn, options);
+var useUpdateSelfEventRegistrationReservations = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfEventRegistrationReservations, options);
 };
 
-// src/mutations/self/events/registration/cart/useRemoveSelfEventRegistrationPurchaseAddOn.ts
-var RemoveSelfEventRegistrationPurchaseAddOn = async ({
+// src/mutations/self/events/registration/useUpdateSelfEventRegistrationResponses.ts
+var UpdateSelfEventRegistrationResponses = async ({
   eventId,
-  registrationId,
-  purchaseId,
-  addOnId,
+  passes,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/addOns/${addOnId}`
+  const { data } = await clientApi.put(
+    `/self/events/${eventId}/registration/questions`,
+    passes
   );
   if (queryClient && data.status === "ok") {
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
-    });
-    queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(eventId),
+      exact: false
     });
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
   }
   return data;
 };
-var useRemoveSelfEventRegistrationPurchaseAddOn = (options = {}) => {
-  return useConnectedMutation_default(RemoveSelfEventRegistrationPurchaseAddOn, options);
+var useUpdateSelfEventRegistrationResponses = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfEventRegistrationResponses, options);
 };
 
-// src/mutations/self/events/registration/cart/useSelectSelfEventRegistrationPurchaseReservation.ts
-var SelectSelfEventRegistrationPurchaseReservation = async ({
+// src/mutations/self/events/registration/useSubmitSelfEventRegistration.ts
+var SubmitSelfEventRegistration = async ({
   eventId,
-  registrationId,
-  purchaseId,
-  locationId,
-  reservationStart,
-  reservationEnd,
+  payment,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/cart/purchases/${purchaseId}/reservations/${locationId}`,
-    {
-      reservationStart,
-      reservationEnd
-    }
+    `/self/events/${eventId}/registration/submit`,
+    payment
   );
   if (queryClient && data.status === "ok") {
-    SET_SELF_EVENT_REGISTRATION_QUERY_DATA(queryClient, [eventId], data, [
-      clientApiParams.locale
-    ]);
     queryClient.removeQueries({
-      queryKey: SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY(
-        eventId,
-        registrationId
-      )
+      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
+      queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
     });
+    ADD_SELF_RELATIONSHIP(
+      queryClient,
+      [clientApiParams.locale],
+      "events",
+      eventId
+    );
   }
   return data;
 };
-var useSelectSelfEventRegistrationPurchaseReservation = (options = {}) => {
-  return useConnectedMutation_default(SelectSelfEventRegistrationPurchaseReservation, options);
+var useSubmitSelfEventRegistration = (options = {}) => {
+  return useConnectedMutation_default(SubmitSelfEventRegistration, options);
 };
 
-// src/mutations/self/events/registration/registered/useAddFreePurchaseAddOns.ts
-var AddFreePurchaseAddOns = async ({
+// src/mutations/self/events/attendee/useAddFreePassAddOns.ts
+var AddFreePassAddOns = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  passId,
   addOnIds,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}/addOns/free`,
+    `/self/events/${eventId}/registration/passes/${passId}/addOns/free`,
     {
       addOnIds
     }
@@ -9085,7 +9042,7 @@ var AddFreePurchaseAddOns = async ({
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
       predicate: ({ queryKey }) => {
-        if (queryKey[0] === "SELF" && queryKey[1] === "EVENT_REGISTRATION" || queryKey[0] === "SELF" && queryKey[1] === "EVENT" && queryKey[3] === "REGISTRATION") {
+        if (queryKey[0] === "SELF" && (queryKey[1] === "REGISTRATION" || queryKey[1] === "ATTENDEE") || queryKey[0] === "SELF" && queryKey[1] === "EVENT" && queryKey[3] === "REGISTRATION") {
           return true;
         }
         return false;
@@ -9094,86 +9051,63 @@ var AddFreePurchaseAddOns = async ({
   }
   return data;
 };
-var useAddFreePurchaseAddOns = (options = {}) => {
-  return useConnectedMutation_default(AddFreePurchaseAddOns, options);
+var useAddFreePassAddOns = (options = {}) => {
+  return useConnectedMutation_default(AddFreePassAddOns, options);
 };
 
-// src/mutations/self/events/registration/registered/useUpdateSelfEventRegistrationPurchaseResponses.ts
-var UpdateSelfEventRegistrationPurchaseResponses = async ({
+// src/mutations/self/events/attendee/useUpdateSelfEventAttendeePassResponses.ts
+var UpdateSelfEventAttendeePassResponses = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  passId,
   questions,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.put(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}`,
+    `/self/events/${eventId}/attendee/passes/${passId}/questions`,
     {
       questions
     }
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
+      queryKey: SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(
         eventId,
-        registrationId,
-        purchaseId
+        passId
       )
     });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
-    });
     queryClient.invalidateQueries({
       queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_PASSES_QUERY_KEY(eventId)
-    });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
-    });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_PASSES_QUERY_KEY(eventId)
+      queryKey: SELF_EVENT_ATTENDEE_PASS_QUERY_KEY(eventId, passId)
     });
   }
   return data;
 };
-var useUpdateSelfEventRegistrationPurchaseResponses = (options = {}) => {
-  return useConnectedMutation_default(UpdateSelfEventRegistrationPurchaseResponses, options);
+var useUpdateSelfEventAttendeePassResponses = (options = {}) => {
+  return useConnectedMutation_default(UpdateSelfEventAttendeePassResponses, options);
 };
 
-// src/mutations/self/events/registration/registered/useTransferPurchase.ts
-var TransferPurchase = async ({
+// src/mutations/self/events/attendee/useTransferPass.ts
+var TransferPass = async ({
   passId,
   eventId,
-  registrationId,
   receiverId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/passes/${passId}/transfer`,
+    `/self/events/${eventId}/registration/passes/${passId}/transfer`,
     {
       receiverId
     }
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(
-        eventId,
-        registrationId,
-        passId
-      )
-    });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
+      queryKey: SELF_EVENT_ATTENDEE_PASS_QUERY_KEY(eventId, passId)
     });
     queryClient.invalidateQueries({
       queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
@@ -9181,36 +9115,28 @@ var TransferPurchase = async ({
   }
   return data;
 };
-var useTransferPurchase = (options = {}) => {
-  return useConnectedMutation_default(TransferPurchase, options);
+var useTransferPass = (options = {}) => {
+  return useConnectedMutation_default(TransferPass, options);
 };
 
-// src/mutations/self/events/registration/registered/useCancelPurchase.ts
-var CancelPurchase = async ({
-  purchaseId,
+// src/mutations/self/events/attendee/useCancelPass.ts
+var CancelPass = async ({
+  passId,
   eventId,
-  registrationId,
   issueRefund,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.put(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}/cancel`,
+    `/self/events/${eventId}/registration/passes/${passId}/cancel`,
     {
       issueRefund
     }
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY(
-        eventId,
-        registrationId,
-        purchaseId
-      )
-    });
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
+      queryKey: SELF_EVENT_ATTENDEE_PASS_QUERY_KEY(eventId, passId)
     });
     queryClient.invalidateQueries({
       queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
@@ -9218,14 +9144,13 @@ var CancelPurchase = async ({
   }
   return data;
 };
-var useCancelPurchase = (options = {}) => {
-  return useConnectedMutation_default(CancelPurchase, options);
+var useCancelPass = (options = {}) => {
+  return useConnectedMutation_default(CancelPass, options);
 };
 
-// src/mutations/self/events/registration/sessions/useSubmitSelfEventRegistrationSessionPasses.ts
+// src/mutations/self/events/attendee/sessions/useSubmitSelfEventAttendeeSessionPasses.ts
 var SubmitSelfEventRegistrationSessionPasses = async ({
   eventId,
-  registrationId,
   sessionId,
   sessionPasses,
   clientApiParams,
@@ -9233,13 +9158,10 @@ var SubmitSelfEventRegistrationSessionPasses = async ({
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/self/events/${eventId}/registration/${registrationId}/sessions/${sessionId}/submit`,
+    `/self/events/${eventId}/registration/sessions/${sessionId}/submit`,
     sessionPasses
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_EVENT_REGISTRATION_QUERY_KEY(eventId)
-    });
     queryClient.invalidateQueries({
       queryKey: SELF_EVENT_ATTENDEE_QUERY_KEY(eventId)
     });
@@ -9256,18 +9178,17 @@ var useSubmitSelfEventRegistrationSessionPasses = (options = {}) => {
   return useConnectedMutation_default(SubmitSelfEventRegistrationSessionPasses, options);
 };
 
-// src/mutations/self/events/registration/sessions/useUpdateSelfEventRegistrationPurchaseSessionResponses.ts
+// src/mutations/self/events/attendee/sessions/useUpdateSelfEventAttendeePurchaseSessionResponses.ts
 var UpdateSelfEventRegistrationPurchaseSessionResponses = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  passId,
   sessionPassId,
   responses,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.put(
-    `/self/events/${eventId}/registration/${registrationId}/purchases/${purchaseId}/sessions/${sessionPassId}`,
+    `/self/events/${eventId}/registration/passes/${passId}/sessions/${sessionPassId}`,
     responses
   );
   return data;
@@ -9466,11 +9387,11 @@ var useRemoveSelfEventSession = (options = {}) => {
 };
 
 // src/mutations/activities/optimistic/UpdateComments.ts
-import { produce as produce5 } from "immer";
+import { produce as produce4 } from "immer";
 var UpdateCommentsSingle = (increment, queryClient, KEY) => {
   queryClient.setQueryData(
     KEY,
-    (originalData) => produce5(originalData, (draft) => {
+    (originalData) => produce4(originalData, (draft) => {
       if (!draft?.data) {
         return;
       }
@@ -9482,7 +9403,7 @@ var UpdateCommentsSingle = (increment, queryClient, KEY) => {
 var UpdateCommentsInfinite = (increment, queryClient, KEY, activityId) => {
   queryClient.setQueriesData(
     { queryKey: KEY, exact: false },
-    (originalData) => produce5(originalData, (draft) => {
+    (originalData) => produce4(originalData, (draft) => {
       if (!draft?.pages || draft.pages.length === 0) {
         return;
       }
@@ -9699,25 +9620,6 @@ var useUpdateSelfImage = (options = {}) => {
   return useConnectedMutation_default(UpdateSelfImage, options);
 };
 
-// src/mutations/self/useUpdateSelfLead.ts
-var UpdateSelfLead = async ({
-  leadId,
-  note,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.put(
-    `/self/leads/${leadId}`,
-    {
-      note
-    }
-  );
-  return data;
-};
-var useUpdateSelfLead = (options = {}) => {
-  return useConnectedMutation_default(UpdateSelfLead, options);
-};
-
 // src/mutations/self/useUpdateSelfNotificationPreferences.ts
 var UpdateSelfNotificationPreferences = async ({
   clientApiParams,
@@ -10643,68 +10545,68 @@ var useRemoveListingSponsor = (options = {}) => {
   return useConnectedMutation_default(RemoveListingSponsor, options);
 };
 
-// src/mutations/listings/useCheckinListingRegistrationPurchase.ts
-var CheckinListingRegistrationPurchase = async ({
+// src/mutations/listings/useCheckinListingAttendeePass.ts
+var CheckinListingAttendeePass = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  accountId,
+  passId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(
-    `/listings/${eventId}/registrations/${registrationId}/purchases/${purchaseId}`
+    `/listings/${eventId}/attendees/${accountId}/passes/${passId}/checkin`
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATIONS_QUERY_KEY(eventId)
+      queryKey: LISTING_ATTENDEES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATION_QUERY_KEY(eventId, registrationId)
+      queryKey: LISTING_ATTENDEE_QUERY_KEY(eventId, accountId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASES_QUERY_KEY(eventId)
+      queryKey: LISTING_PASSES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASE_QUERY_KEY(eventId, purchaseId)
+      queryKey: LISTING_PASS_QUERY_KEY(eventId, passId)
     });
   }
   return data;
 };
-var useCheckinListingRegistrationPurchase = (options = {}) => {
-  return useConnectedMutation_default(CheckinListingRegistrationPurchase, options);
+var useCheckinListingAttendeePass = (options = {}) => {
+  return useConnectedMutation_default(CheckinListingAttendeePass, options);
 };
 
-// src/mutations/listings/useUndoCheckinListingRegistrationPurchase.ts
-var UndoCheckinListingRegistrationPurchase = async ({
+// src/mutations/listings/useUndoCheckinListingAttendeePass.ts
+var UndoCheckinListingAttendeePass = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  accountId,
+  passId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.delete(
-    `/listings/${eventId}/registrations/${registrationId}/purchases/${purchaseId}`
+    `/listings/${eventId}/attendees/${accountId}/passes/${passId}/checkin`
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATIONS_QUERY_KEY(eventId)
+      queryKey: LISTING_ATTENDEES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATION_QUERY_KEY(eventId, registrationId)
+      queryKey: LISTING_ATTENDEE_QUERY_KEY(eventId, accountId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASES_QUERY_KEY(eventId)
+      queryKey: LISTING_PASSES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASE_QUERY_KEY(eventId, purchaseId)
+      queryKey: LISTING_PASS_QUERY_KEY(eventId, passId)
     });
   }
   return data;
 };
-var useUndoCheckinListingRegistrationPurchase = (options = {}) => {
-  return useConnectedMutation_default(UndoCheckinListingRegistrationPurchase, options);
+var useUndoCheckinListingAttendeePass = (options = {}) => {
+  return useConnectedMutation_default(UndoCheckinListingAttendeePass, options);
 };
 
 // src/mutations/listings/useUpdateListing.ts
@@ -10885,41 +10787,41 @@ var useRemoveListingCoHost = (options = {}) => {
   return useConnectedMutation_default(RemoveListingCoHost, options);
 };
 
-// src/mutations/listings/useUpdateListingRegistrationPurchaseResponses.ts
-var UpdateListingRegistrationPurchaseResponses = async ({
+// src/mutations/listings/useUpdateListingAttendeePassResponses.ts
+var UpdateListingRegistrationPassResponses = async ({
   eventId,
-  registrationId,
-  purchaseId,
+  accountId,
+  passId,
   questions,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.put(
-    `/listings/${eventId}/registrations/${registrationId}/purchases/${purchaseId}`,
+    `/listings/${eventId}/attendees/${accountId}/passes/${passId}/responses`,
     {
       questions
     }
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY(
+      queryKey: LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY(
         eventId,
-        registrationId,
-        purchaseId
+        accountId,
+        passId
       )
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATIONS_QUERY_KEY(eventId)
+      queryKey: LISTING_ATTENDEES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_REGISTRATION_QUERY_KEY(eventId, registrationId)
+      queryKey: LISTING_ATTENDEE_QUERY_KEY(eventId, accountId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASES_QUERY_KEY(eventId)
+      queryKey: LISTING_PASSES_QUERY_KEY(eventId)
     });
     queryClient.invalidateQueries({
-      queryKey: LISTING_PURCHASE_QUERY_KEY(eventId, purchaseId)
+      queryKey: LISTING_PASS_QUERY_KEY(eventId, passId)
     });
     queryClient.invalidateQueries({
       queryKey: LISTING_REPORT_QUERY_KEY(eventId)
@@ -10927,8 +10829,8 @@ var UpdateListingRegistrationPurchaseResponses = async ({
   }
   return data;
 };
-var useUpdateListingRegistrationPurchaseResponses = (options = {}) => {
-  return useConnectedMutation_default(UpdateListingRegistrationPurchaseResponses, options);
+var useUpdateListingRegistrationPassResponses = (options = {}) => {
+  return useConnectedMutation_default(UpdateListingRegistrationPassResponses, options);
 };
 
 // src/mutations/storage/useUploadFile.ts
@@ -11177,7 +11079,7 @@ var useUpdateThreadMessage = (options = {}) => {
 };
 
 // src/mutations/threads/useDeleteThreadMessage.ts
-import { produce as produce6 } from "immer";
+import { produce as produce5 } from "immer";
 var DeleteThreadMessage = async ({
   threadId,
   messageId,
@@ -11201,7 +11103,7 @@ var DeleteThreadMessage = async ({
       ],
       (oldData) => {
         if (!oldData) return oldData;
-        return produce6(oldData, (draft) => {
+        return produce5(oldData, (draft) => {
           draft.pages.forEach((page) => {
             const index = page.data.findIndex((m) => m.id === messageId);
             if (index !== -1) {
@@ -11387,13 +11289,11 @@ export {
   AddChannelCollectionContent,
   AddChannelInterest,
   AddContentInterest,
-  AddFreePurchaseAddOns,
+  AddFreePassAddOns,
   AddListingCoHost,
   AddListingSponsor,
   AddSelfChatChannelMember,
   AddSelfDelegate,
-  AddSelfEventRegistrationPurchase,
-  AddSelfEventRegistrationPurchaseAddOn,
   AddSelfEventSession,
   AddSelfInterests,
   AddThreadMember,
@@ -11421,10 +11321,10 @@ export {
   CacheIndividualQueries,
   CancelGroupInvitation,
   CancelGroupRequest,
-  CancelPurchase,
+  CancelPass,
   CancelSubscription,
   CapturePaymentIntent,
-  CheckinListingRegistrationPurchase,
+  CheckinListingAttendeePass,
   CompleteEventActivation,
   ConnectedXMProvider,
   ContentGuestType,
@@ -11434,7 +11334,6 @@ export {
   CreateChannelContent,
   CreateChannelSubscriber,
   CreateContentGuest,
-  CreateEventLead,
   CreateGroup,
   CreateGroupAnnouncement,
   CreateGroupInvitations,
@@ -11444,8 +11343,10 @@ export {
   CreateListingQuestion,
   CreateListingSession,
   CreateListingSpeaker,
+  CreateSelfAddress,
   CreateSelfChatChannel,
   CreateSelfChatChannelMessage,
+  CreateSelfLead,
   CreateSubscription,
   CreateSupportTicket,
   CreateTeamAccount,
@@ -11467,8 +11368,10 @@ export {
   DeleteListingSpeaker,
   DeleteReshare,
   DeleteSelf,
+  DeleteSelfAddress,
   DeleteSelfChatChannel,
   DeleteSelfChatChannelMessage,
+  DeleteSelfLead,
   DeleteSelfPushDevice,
   DeleteThreadMember,
   DeleteThreadMessage,
@@ -11476,6 +11379,7 @@ export {
   DisableIntegration,
   ERR_FEATURE_NOT_AVAILABLE,
   ERR_INTEGRATION_PERMISSION_DENIED,
+  ERR_KNOWN_ERROR,
   ERR_NOT_EVENT_REGISTERED,
   ERR_NOT_GROUP_MEMBER,
   ERR_REGISTRATION_UNAVAILABLE,
@@ -11490,8 +11394,6 @@ export {
   EVENT_FAQ_SECTION_QUESTION_QUERY_KEY,
   EVENT_PAGES_QUERY_KEY,
   EVENT_PAGE_QUERY_KEY,
-  EVENT_PASS_TYPES_QUERY_KEY,
-  EVENT_PASS_TYPE_QUERY_KEY,
   EVENT_QUERY_KEY,
   EVENT_QUESTION_VALUES_QUERY_KEY,
   EVENT_REGISTRANTS_QUERY_KEY,
@@ -11500,7 +11402,6 @@ export {
   EVENT_SPEAKERS_QUERY_KEY,
   EVENT_SPEAKER_QUERY_KEY,
   EVENT_SPONSORS_QUERY_KEY,
-  EVENT_TRANSFER_LOGS_QUERY_KEY,
   EnableIntegration,
   EventEmailType,
   EventSource,
@@ -11562,8 +11463,6 @@ export {
   GetEventFaqs,
   GetEventPage,
   GetEventPages,
-  GetEventPassType,
-  GetEventPassTypes,
   GetEventQuestionSearchValues,
   GetEventRegistrants,
   GetEventSession,
@@ -11597,7 +11496,7 @@ export {
   GetLevel,
   GetLevelSponsors,
   GetLevels,
-  GetListingRegistrationPurchaseSections,
+  GetListingAttendeePassQuestionSections,
   GetManagedChannel,
   GetManagedChannelCollection,
   GetManagedChannelCollectionContents,
@@ -11616,6 +11515,8 @@ export {
   GetOrganizationSubscriptionProducts,
   GetSelf,
   GetSelfActivities,
+  GetSelfAddress,
+  GetSelfAddresses,
   GetSelfAnnouncement,
   GetSelfChatChannel,
   GetSelfChatChannelMembers,
@@ -11625,41 +11526,44 @@ export {
   GetSelfDelegateOf,
   GetSelfDelegates,
   GetSelfEventAttendee,
-  GetSelfEventCoupons,
+  GetSelfEventAttendeeCoupon,
+  GetSelfEventAttendeeCouponPasses,
+  GetSelfEventAttendeeCoupons,
+  GetSelfEventAttendeePass,
+  GetSelfEventAttendeePassAddOns,
+  GetSelfEventAttendeePassAddOnsIntent,
+  GetSelfEventAttendeePassQuestionSections,
+  GetSelfEventAttendeePayment,
+  GetSelfEventAttendeeSessionPassesIntent,
+  GetSelfEventAttendeeTransfersLogs,
   GetSelfEventListing,
   GetSelfEventListingAnnouncement,
   GetSelfEventListingAnnouncements,
+  GetSelfEventListingAttendees,
   GetSelfEventListingCoHosts,
   GetSelfEventListingEmail,
-  GetSelfEventListingPurchase,
-  GetSelfEventListingPurchases,
+  GetSelfEventListingPass,
+  GetSelfEventListingPasses,
   GetSelfEventListingQuestions,
   GetSelfEventListingRegistration,
-  GetSelfEventListingRegistrations,
   GetSelfEventListingReport,
   GetSelfEventListings,
-  GetSelfEventPasses,
   GetSelfEventRegistration,
-  GetSelfEventRegistrationCoupon,
-  GetSelfEventRegistrationCouponPurchases,
-  GetSelfEventRegistrationCoupons,
+  GetSelfEventRegistrationAddOns,
   GetSelfEventRegistrationIntent,
-  GetSelfEventRegistrationPayment,
-  GetSelfEventRegistrationPurchase,
-  GetSelfEventRegistrationPurchaseAddOns,
-  GetSelfEventRegistrationPurchaseAddOnsIntent,
-  GetSelfEventRegistrationPurchaseReservationSections,
-  GetSelfEventRegistrationPurchaseSections,
-  GetSelfEventRegistrationSessionPassesIntent,
+  GetSelfEventRegistrationPassTypes,
+  GetSelfEventRegistrationQuestions,
+  GetSelfEventRegistrationRoomTypes,
   GetSelfEventSessions,
   GetSelfEventTicketCouponIntent,
-  GetSelfEventTransfersLogs,
   GetSelfEvents,
   GetSelfFeed,
   GetSelfGroupActivities,
   GetSelfGroupMembership,
   GetSelfGroupMemberships,
   GetSelfInterests,
+  GetSelfLead,
+  GetSelfLeads,
   GetSelfNotificationPreferences,
   GetSelfNotifications,
   GetSelfPushDevice,
@@ -11703,16 +11607,17 @@ export {
   LISTINGS_QUERY_KEY,
   LISTING_ANNOUNCEMENTS_QUERY_KEY,
   LISTING_ANNOUNCEMENT_QUERY_KEY,
+  LISTING_ATTENDEES_QUERY_KEY,
+  LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY,
+  LISTING_ATTENDEE_QUERY_KEY,
   LISTING_CO_HOSTS_QUERY_KEY,
   LISTING_EMAIL_QUERY_KEY,
-  LISTING_PURCHASES_QUERY_KEY,
-  LISTING_PURCHASE_QUERY_KEY,
+  LISTING_PASSES_QUERY_KEY,
+  LISTING_PASS_QUERY_KEY,
   LISTING_QUERY_KEY,
   LISTING_QUESTIONS_QUERY_KEY,
-  LISTING_REGISTRATIONS_QUERY_KEY,
-  LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY,
-  LISTING_REGISTRATION_QUERY_KEY,
   LISTING_REPORT_QUERY_KEY,
+  LeadStatus,
   LeaveGroup,
   LeaveSelfChatChannel,
   LikeActivity,
@@ -11756,12 +11661,12 @@ export {
   RemoveListingSponsor,
   RemoveSelfDelegate,
   RemoveSelfEventRegistrationCoupon,
-  RemoveSelfEventRegistrationPurchase,
-  RemoveSelfEventRegistrationPurchaseAddOn,
   RemoveSelfEventSession,
   RemoveThreadMessageReaction,
   ReshareActivity,
   SELF_ACTIVITIES_QUERY_KEY,
+  SELF_ADDRESSES_QUERY_KEY,
+  SELF_ADDRESS_QUERY_KEY,
   SELF_ANNOUNCEMENT_QUERY_KEY,
   SELF_CHAT_CHANNELS_QUERY_KEY,
   SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY,
@@ -11771,21 +11676,23 @@ export {
   SELF_DELEGATES_QUERY_KEY,
   SELF_DELEGATE_OF_QUERY_KEY,
   SELF_EVENTS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_COUPONS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_COUPON_PASSES_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_PASS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_PAYMENT_QUERY_KEY,
   SELF_EVENT_ATTENDEE_QUERY_KEY,
-  SELF_EVENT_COUPONS_QUERY_KEY,
-  SELF_EVENT_PASSES_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_COUPONS_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_SESSION_PASSES_INTENT_QUERY_KEY,
+  SELF_EVENT_ATTENDEE_TRANSFER_LOGS_QUERY_KEY,
+  SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_KEY,
   SELF_EVENT_REGISTRATION_COUPON_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_COUPON_REGISTRATIONS_QUERY_KEY,
   SELF_EVENT_REGISTRATION_INTENT_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_PAYMENT_QUERY_KEY,
+  SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_KEY,
   SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_INTENT_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_PURCHASE_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_KEY,
   SELF_EVENT_REGISTRATION_QUERY_KEY,
-  SELF_EVENT_REGISTRATION_SESSION_PASSES_INTENT_QUERY_KEY,
+  SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_KEY,
+  SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_KEY,
   SELF_EVENT_SESSIONS_QUERY_KEY,
   SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY,
   SELF_FEED_QUERY_KEY,
@@ -11794,6 +11701,8 @@ export {
   SELF_GROUP_MEMBERSHIP_QUERY_KEY,
   SELF_INTERESTS_QUERY_KEY,
   SELF_INVOICE_INTENT_QUERY_KEY,
+  SELF_LEADS_QUERY_KEY,
+  SELF_LEAD_QUERY_KEY,
   SELF_NOTIFICATIONS_QUERY_KEY,
   SELF_PREFERENCES_QUERY_KEY,
   SELF_PUSH_DEVICES_QUERY_KEY,
@@ -11839,8 +11748,6 @@ export {
   SET_EVENT_FAQ_SECTION_QUESTION_QUERY_DATA,
   SET_EVENT_PAGES_QUERY_DATA,
   SET_EVENT_PAGE_QUERY_DATA,
-  SET_EVENT_PASS_TYPES_QUERY_DATA,
-  SET_EVENT_PASS_TYPE_QUERY_DATA,
   SET_EVENT_QUERY_DATA,
   SET_EVENT_REGISTRANTS_QUERY_DATA,
   SET_EVENT_SESSIONS_QUERY_DATA,
@@ -11868,11 +11775,11 @@ export {
   SET_LEVEL_QUERY_DATA,
   SET_LEVEL_SPONSORS_QUERY_DATA,
   SET_LISTING_ANNOUNCEMENT_QUERY_KEY,
+  SET_LISTING_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_DATA,
+  SET_LISTING_ATTENDEE_QUERY_KEY,
   SET_LISTING_EMAIL_QUERY_DATA,
-  SET_LISTING_PURCHASE_QUERY_KEY,
+  SET_LISTING_PASS_QUERY_KEY,
   SET_LISTING_QUERY_DATA,
-  SET_LISTING_REGISTRATION_PURCHASE_SECTIONS_QUERY_DATA,
-  SET_LISTING_REGISTRATION_QUERY_KEY,
   SET_MANAGED_CHANNELS_QUERY_DATA,
   SET_MANAGED_CHANNEL_COLLECTIONS_QUERY_DATA,
   SET_MANAGED_CHANNEL_COLLECTION_QUERY_DATA,
@@ -11887,15 +11794,17 @@ export {
   SET_SELF_CHAT_CHANNEL_MEMBERS_QUERY_DATA,
   SET_SELF_CHAT_CHANNEL_MESSAGES_QUERY_DATA,
   SET_SELF_CHAT_CHANNEL_QUERY_DATA,
+  SET_SELF_EVENT_ATTENDEE_PASS_ADD_ONS_QUERY_DATA,
+  SET_SELF_EVENT_ATTENDEE_PASS_QUERY_DATA,
+  SET_SELF_EVENT_ATTENDEE_PASS_QUESTION_SECTIONS_QUERY_DATA,
+  SET_SELF_EVENT_ATTENDEE_PAYMENT_QUERY_DATA,
   SET_SELF_EVENT_ATTENDEE_QUERY_DATA,
-  SET_SELF_EVENT_PASSES_QUERY_DATA,
+  SET_SELF_EVENT_REGISTRATION_ADD_ONS_QUERY_DATA,
   SET_SELF_EVENT_REGISTRATION_COUPON_QUERY_DATA,
-  SET_SELF_EVENT_REGISTRATION_PAYMENT_QUERY_DATA,
-  SET_SELF_EVENT_REGISTRATION_PURCHASE_ADD_ONS_QUERY_DATA,
-  SET_SELF_EVENT_REGISTRATION_PURCHASE_QUERY_DATA,
-  SET_SELF_EVENT_REGISTRATION_PURCHASE_RESERVATION_SECTIONS_QUERY_DATA,
-  SET_SELF_EVENT_REGISTRATION_PURCHASE_SECTIONS_QUERY_DATA,
+  SET_SELF_EVENT_REGISTRATION_PASS_TYPES_QUERY_DATA,
   SET_SELF_EVENT_REGISTRATION_QUERY_DATA,
+  SET_SELF_EVENT_REGISTRATION_QUESTIONS_QUERY_DATA,
+  SET_SELF_EVENT_REGISTRATION_ROOM_TYPES_QUERY_DATA,
   SET_SELF_GROUP_MEMBERSHIP_QUERY_DATA,
   SET_SELF_QUERY_DATA,
   SET_SERIES_EVENTS_QUERY_DATA,
@@ -11915,7 +11824,6 @@ export {
   SUBSCRIBED_CHANNELS_QUERY_KEY,
   SUBSCRIBED_CONTENTS_QUERY_KEY,
   SelectSelfEventRegistrationCoupon,
-  SelectSelfEventRegistrationPurchaseReservation,
   SelfCreateActivity,
   SelfUpdateGroupMembership,
   SessionPassStatus,
@@ -11941,8 +11849,8 @@ export {
   ThreadMessageType,
   TicketEventAccessLevel,
   TicketVisibility,
-  TransferPurchase,
-  UndoCheckinListingRegistrationPurchase,
+  TransferPass,
+  UndoCheckinListingAttendeePass,
   UnfollowAccount,
   UnlikeActivity,
   UnlikeContent,
@@ -11955,14 +11863,18 @@ export {
   UpdateListing,
   UpdateListingEmail,
   UpdateListingQuestion,
-  UpdateListingRegistrationPurchaseResponses,
+  UpdateListingRegistrationPassResponses,
   UpdateListingSession,
   UpdateListingSpeaker,
   UpdateSelf,
+  UpdateSelfAddress,
   UpdateSelfChatChannelNotifications,
-  UpdateSelfEventRegistrationPurchaseResponses,
+  UpdateSelfEventAttendeePassResponses,
+  UpdateSelfEventRegistrationPasses,
+  UpdateSelfEventRegistrationPurchaseAddOn,
   UpdateSelfEventRegistrationPurchaseSessionResponses,
-  UpdateSelfEventRegistrationQuestionResponse,
+  UpdateSelfEventRegistrationReservations,
+  UpdateSelfEventRegistrationResponses,
   UpdateSelfImage,
   UpdateSelfLead,
   UpdateSelfNotificationPreferences,
@@ -12017,13 +11929,11 @@ export {
   useAddChannelCollectionContent,
   useAddChannelInterest,
   useAddContentInterest,
-  useAddFreePurchaseAddOns,
+  useAddFreePassAddOns,
   useAddListingCoHost,
   useAddListingSponsor,
   useAddSelfChatChannelMember,
   useAddSelfDelegate,
-  useAddSelfEventRegistrationPurchase,
-  useAddSelfEventRegistrationPurchaseAddOn,
   useAddSelfEventSession,
   useAddSelfInterests,
   useAddThreadMember,
@@ -12032,10 +11942,10 @@ export {
   useBlockIntegration,
   useCancelGroupInvitation,
   useCancelGroupRequest,
-  useCancelPurchase,
+  useCancelPass,
   useCancelSubscription,
   useCapturePaymentIntent,
-  useCheckinListingRegistrationPurchase,
+  useCheckinListingAttendeePass,
   useCompleteEventActivation,
   useConnectedInfiniteQuery,
   useConnectedMutation,
@@ -12046,7 +11956,6 @@ export {
   useCreateChannelContent,
   useCreateChannelSubscriber,
   useCreateContentGuest,
-  useCreateEventLead,
   useCreateGroup,
   useCreateGroupAnnouncement,
   useCreateGroupInvitations,
@@ -12056,8 +11965,10 @@ export {
   useCreateListingQuestion,
   useCreateListingSession,
   useCreateListingSpeaker,
+  useCreateSelfAddress,
   useCreateSelfChatChannel,
   useCreateSelfChatChannelMessage,
+  useCreateSelfLead,
   useCreateSubscription,
   useCreateSupportTicket,
   useCreateTeamAccount,
@@ -12077,8 +11988,10 @@ export {
   useDeleteListingSpeaker,
   useDeleteReshare,
   useDeleteSelf,
+  useDeleteSelfAddress,
   useDeleteSelfChatChannel,
   useDeleteSelfChatChannelMessage,
+  useDeleteSelfLead,
   useDeleteSelfPushDevice,
   useDeleteThreadMember,
   useDeleteThreadMessage,
@@ -12123,8 +12036,6 @@ export {
   useGetEventFaqs,
   useGetEventPage,
   useGetEventPages,
-  useGetEventPassType,
-  useGetEventPassTypes,
   useGetEventQuestionSearchValues,
   useGetEventRegistrants,
   useGetEventSession,
@@ -12158,7 +12069,7 @@ export {
   useGetLevel,
   useGetLevelSponsors,
   useGetLevels,
-  useGetListingRegistrationPurchaseSections,
+  useGetListingAttendeePassQuestionSections,
   useGetManagedChannel,
   useGetManagedChannelCollection,
   useGetManagedChannelCollectionContents,
@@ -12177,6 +12088,8 @@ export {
   useGetOrganizationSubscriptionProducts,
   useGetSelf,
   useGetSelfActivities,
+  useGetSelfAddress,
+  useGetSelfAddresses,
   useGetSelfAnnouncement,
   useGetSelfChatChannel,
   useGetSelfChatChannelMembers,
@@ -12186,41 +12099,44 @@ export {
   useGetSelfDelegateOf,
   useGetSelfDelegates,
   useGetSelfEventAttendee,
-  useGetSelfEventCoupons,
+  useGetSelfEventAttendeeCoupon,
+  useGetSelfEventAttendeeCouponPasses,
+  useGetSelfEventAttendeeCoupons,
+  useGetSelfEventAttendeePass,
+  useGetSelfEventAttendeePassAddOns,
+  useGetSelfEventAttendeePassAddOnsIntent,
+  useGetSelfEventAttendeePassQuestionSections,
+  useGetSelfEventAttendeePayment,
+  useGetSelfEventAttendeeSessionPassesIntent,
+  useGetSelfEventAttendeeTransfersLogs,
   useGetSelfEventListing,
   useGetSelfEventListingAnnouncement,
   useGetSelfEventListingAnnouncements,
   useGetSelfEventListingCoHosts,
   useGetSelfEventListingEmail,
-  useGetSelfEventListingPurchase,
-  useGetSelfEventListingPurchases,
+  useGetSelfEventListingPass,
+  useGetSelfEventListingPasses,
   useGetSelfEventListingQuestions,
   useGetSelfEventListingRegistration,
   useGetSelfEventListingReport,
   useGetSelfEventListings,
   useGetSelfEventListingsRegistrations,
-  useGetSelfEventPasses,
   useGetSelfEventRegistration,
-  useGetSelfEventRegistrationCoupon,
-  useGetSelfEventRegistrationCouponPurchases,
-  useGetSelfEventRegistrationCoupons,
+  useGetSelfEventRegistrationAddOns,
   useGetSelfEventRegistrationIntent,
-  useGetSelfEventRegistrationPayment,
-  useGetSelfEventRegistrationPurchase,
-  useGetSelfEventRegistrationPurchaseAddOns,
-  useGetSelfEventRegistrationPurchaseAddOnsIntent,
-  useGetSelfEventRegistrationPurchaseReservationSections,
-  useGetSelfEventRegistrationPurchaseSections,
-  useGetSelfEventRegistrationSessionPassesIntent,
+  useGetSelfEventRegistrationPassTypes,
+  useGetSelfEventRegistrationQuestions,
+  useGetSelfEventRegistrationRoomTypes,
   useGetSelfEventSessions,
   useGetSelfEventTicketCouponIntent,
-  useGetSelfEventTransfersLogs,
   useGetSelfEvents,
   useGetSelfFeed,
   useGetSelfGroupActivities,
   useGetSelfGroupMembership,
   useGetSelfGroupMemberships,
   useGetSelfInterests,
+  useGetSelfLead,
+  useGetSelfLeads,
   useGetSelfNotificationPreferences,
   useGetSelfNotifications,
   useGetSelfPushDevice,
@@ -12267,20 +12183,17 @@ export {
   useRemoveListingSponsor,
   useRemoveSelfDelegate,
   useRemoveSelfEventRegistrationCoupon,
-  useRemoveSelfEventRegistrationPurchase,
-  useRemoveSelfEventRegistrationPurchaseAddOn,
   useRemoveSelfEventSession,
   useRemoveThreadMessageReaction,
   useReshareActivity,
   useSelectSelfEventRegistrationCoupon,
-  useSelectSelfEventRegistrationPurchaseReservation,
   useSelfCreateActivity,
   useSelfUpdateGroupMembership,
   useSetContentPublishSchedule,
   useSubmitSelfEventRegistration,
   useSubmitSelfEventRegistrationSessionPasses,
-  useTransferPurchase,
-  useUndoCheckinListingRegistrationPurchase,
+  useTransferPass,
+  useUndoCheckinListingAttendeePass,
   useUnfollowAccount,
   useUnlikeActivity,
   useUnlikeContent,
@@ -12293,14 +12206,18 @@ export {
   useUpdateListing,
   useUpdateListingEmail,
   useUpdateListingQuestion,
-  useUpdateListingRegistrationPurchaseResponses,
+  useUpdateListingRegistrationPassResponses,
   useUpdateListingSession,
   useUpdateListingSpeaker,
   useUpdateSelf,
+  useUpdateSelfAddress,
   useUpdateSelfChatChannelNotifications,
-  useUpdateSelfEventRegistrationPurchaseResponses,
+  useUpdateSelfEventAttendeePassResponses,
+  useUpdateSelfEventRegistrationPasses,
+  useUpdateSelfEventRegistrationPurchaseAddOn,
   useUpdateSelfEventRegistrationPurchaseSessionResponses,
-  useUpdateSelfEventRegistrationQuestionResponse,
+  useUpdateSelfEventRegistrationReservations,
+  useUpdateSelfEventRegistrationResponses,
   useUpdateSelfImage,
   useUpdateSelfLead,
   useUpdateSelfNotificationPreferences,