@htlkg/data 0.0.21 → 0.0.23

package/dist/hooks/index.js

@@ -55,7 +55,7 @@ function createDataHook(config) {
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter7,
+    buildFilter: buildFilter11,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -65,8 +65,8 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter7) {
-        return buildFilter7(options);
+      if (buildFilter11) {
+        return buildFilter11(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
@@ -126,7 +126,171 @@ function createDataHook(config) {
   };
 }
 
-// src/hooks/useBrands.ts
+// src/hooks/createPaginatedDataHook.ts
+import { ref as ref2, computed as computed2, onMounted as onMounted2 } from "vue";
+var ACTIVE_FILTER = {
+  or: [{ deletedAt: { attributeExists: false } }, { deletedAt: { eq: null } }]
+};
+var DELETED_FILTER = {
+  deletedAt: { gt: "" }
+};
+function createPaginatedDataHook(config) {
+  const {
+    model,
+    defaultPageSize = 25,
+    selectionSet,
+    transform,
+    buildFilter: buildFilter11,
+    dataPropertyName = "data",
+    baseFilter
+  } = config;
+  return function usePaginatedData(options = {}) {
+    const { filter: additionalFilter, pageSize = defaultPageSize, autoFetch = true } = options;
+    const data = ref2([]);
+    const loading = ref2(false);
+    const initialLoading = ref2(false);
+    const loadingMore = ref2(false);
+    const error = ref2(null);
+    const pagination = ref2({
+      nextToken: null,
+      hasMore: true,
+      loadedCount: 0
+    });
+    const searchFilter = ref2(null);
+    const hasMore = computed2(() => pagination.value.hasMore);
+    const getFilter = () => {
+      const filters = [];
+      if (baseFilter) {
+        filters.push(baseFilter);
+      }
+      if (buildFilter11) {
+        const customFilter = buildFilter11(options);
+        if (customFilter) {
+          filters.push(customFilter);
+        }
+      }
+      if (additionalFilter && Object.keys(additionalFilter).length > 0) {
+        filters.push(additionalFilter);
+      }
+      if (searchFilter.value && Object.keys(searchFilter.value).length > 0) {
+        filters.push(searchFilter.value);
+      }
+      if (filters.length === 0) {
+        return void 0;
+      }
+      if (filters.length === 1) {
+        return filters[0];
+      }
+      return { and: filters };
+    };
+    async function fetchPage(nextToken, append = false) {
+      if (!append) {
+        initialLoading.value = true;
+      } else {
+        loadingMore.value = true;
+      }
+      loading.value = true;
+      error.value = null;
+      try {
+        const queryOptions = {
+          limit: pageSize
+        };
+        const filter = getFilter();
+        if (filter) {
+          queryOptions.filter = filter;
+        }
+        if (nextToken) {
+          queryOptions.nextToken = nextToken;
+        }
+        if (selectionSet) {
+          queryOptions.selectionSet = selectionSet;
+        }
+        const response = await query(model, "list", queryOptions);
+        if (hasErrors(response)) {
+          throw new Error(getErrorMessage(response) || `Failed to fetch ${model}`);
+        }
+        const items = response.data || [];
+        const transformedItems = transform ? items.map(transform) : items;
+        if (append) {
+          data.value = [...data.value, ...transformedItems];
+        } else {
+          data.value = transformedItems;
+        }
+        const responseNextToken = response.nextToken;
+        pagination.value = {
+          nextToken: responseNextToken || null,
+          hasMore: !!responseNextToken,
+          loadedCount: data.value.length
+        };
+      } catch (e) {
+        error.value = e;
+        console.error(`[use${model}] Error fetching ${model}:`, e);
+      } finally {
+        loading.value = false;
+        initialLoading.value = false;
+        loadingMore.value = false;
+      }
+    }
+    async function loadMore() {
+      if (loadingMore.value || !pagination.value.hasMore) {
+        return;
+      }
+      await fetchPage(pagination.value.nextToken, true);
+    }
+    async function refetch() {
+      pagination.value = {
+        nextToken: null,
+        hasMore: true,
+        loadedCount: 0
+      };
+      await fetchPage(null, false);
+    }
+    function reset() {
+      data.value = [];
+      error.value = null;
+      searchFilter.value = null;
+      pagination.value = {
+        nextToken: null,
+        hasMore: true,
+        loadedCount: 0
+      };
+    }
+    async function setSearchFilter(filter) {
+      searchFilter.value = filter;
+      pagination.value = {
+        nextToken: null,
+        hasMore: true,
+        loadedCount: 0
+      };
+      await fetchPage(null, false);
+    }
+    if (autoFetch) {
+      onMounted2(() => {
+        fetchPage(null, false);
+      });
+    }
+    const result = {
+      data,
+      loading,
+      initialLoading,
+      loadingMore,
+      error,
+      pagination,
+      hasMore,
+      loadMore,
+      refetch,
+      reset,
+      setSearchFilter,
+      searchFilter
+    };
+    if (dataPropertyName !== "data") {
+      result[dataPropertyName] = data;
+    }
+    return result;
+  };
+}
+
+// src/hooks/brands/useBrands.ts
 function buildFilter(options) {
   let filter = options.filter || {};
   if (options.accountId) {
@@ -156,23 +320,96 @@ function useBrands(options = {}) {
   };
 }
 
-// src/hooks/useAccounts.ts
-var useAccountsInternal = createDataHook({
-  model: "Account",
-  dataPropertyName: "accounts"
+// src/hooks/brands/usePaginatedBrands.ts
+function buildFilter2(options) {
+  const conditions = [];
+  if (options.accountId) {
+    conditions.push({ accountId: { eq: options.accountId } });
+  }
+  if (options.filter && Object.keys(options.filter).length > 0) {
+    conditions.push(options.filter);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+function transformBrand(brand) {
+  return {
+    ...brand,
+    accountName: brand.account?.name || ""
+  };
+}
+var BRAND_SELECTION_SET = [
+  "id",
+  "name",
+  "accountId",
+  "logo",
+  "timezone",
+  "status",
+  "settings",
+  "deletedAt",
+  "deletedBy",
+  "account.name"
+];
+var useActiveBrandsInternal = createPaginatedDataHook({
+  model: "Brand",
+  dataPropertyName: "brands",
+  defaultPageSize: 25,
+  selectionSet: BRAND_SELECTION_SET,
+  transform: transformBrand,
+  buildFilter: buildFilter2,
+  baseFilter: ACTIVE_FILTER
 });
-function useAccounts(options = {}) {
-  const result = useAccountsInternal(options);
+var useDeletedBrandsInternal = createPaginatedDataHook({
+  model: "Brand",
+  dataPropertyName: "brands",
+  defaultPageSize: 25,
+  selectionSet: BRAND_SELECTION_SET,
+  transform: transformBrand,
+  buildFilter: buildFilter2,
+  baseFilter: DELETED_FILTER
+});
+function useActiveBrands(options = {}) {
+  const result = useActiveBrandsInternal(options);
   return {
-    accounts: result.accounts,
+    brands: result.brands,
     loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
     error: result.error,
-    refetch: result.refetch
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+function useDeletedBrands(options = {}) {
+  const result = useDeletedBrandsInternal(options);
+  return {
+    brands: result.brands,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
   };
 }
 
-// src/hooks/useUsers.ts
-function buildFilter2(options) {
+// src/hooks/users/useUsers.ts
+function buildFilter3(options) {
   let filter = options.filter || {};
   if (options.brandId) {
     filter = { ...filter, brandIds: { contains: options.brandId } };
@@ -185,7 +422,7 @@ function buildFilter2(options) {
 var useUsersInternal = createDataHook({
   model: "User",
   dataPropertyName: "users",
-  buildFilter: buildFilter2
+  buildFilter: buildFilter3
 });
 function useUsers(options = {}) {
   const result = useUsersInternal(options);
@@ -197,8 +434,419 @@ function useUsers(options = {}) {
   };
 }
 
-// src/hooks/useProducts.ts
-function buildFilter3(options) {
+// src/hooks/users/usePaginatedUsers.ts
+function buildFilter4(options) {
+  const conditions = [];
+  if (options.brandId) {
+    conditions.push({ brandIds: { contains: options.brandId } });
+  }
+  if (options.accountId) {
+    conditions.push({ accountId: { eq: options.accountId } });
+  }
+  if (options.filter && Object.keys(options.filter).length > 0) {
+    conditions.push(options.filter);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+function transformUser(user) {
+  return {
+    ...user,
+    accountName: user.account?.name || ""
+  };
+}
+var USER_SELECTION_SET = [
+  "id",
+  "email",
+  "accountId",
+  "brandIds",
+  "roles",
+  "status",
+  "lastLogin",
+  "createdAt",
+  "deletedAt",
+  "deletedBy",
+  "account.name"
+];
+var useActiveUsersInternal = createPaginatedDataHook({
+  model: "User",
+  dataPropertyName: "users",
+  defaultPageSize: 25,
+  selectionSet: USER_SELECTION_SET,
+  transform: transformUser,
+  buildFilter: buildFilter4,
+  baseFilter: ACTIVE_FILTER
+});
+var useDeletedUsersInternal = createPaginatedDataHook({
+  model: "User",
+  dataPropertyName: "users",
+  defaultPageSize: 25,
+  selectionSet: USER_SELECTION_SET,
+  transform: transformUser,
+  buildFilter: buildFilter4,
+  baseFilter: DELETED_FILTER
+});
+function useActiveUsers(options = {}) {
+  const result = useActiveUsersInternal(options);
+  return {
+    users: result.users,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+function useDeletedUsers(options = {}) {
+  const result = useDeletedUsersInternal(options);
+  return {
+    users: result.users,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+
+// src/hooks/accounts/useAccounts.ts
+function transformAccount(account) {
+  const brands = account.brands || [];
+  return {
+    ...account,
+    brands,
+    brandCount: brands.length
+  };
+}
+var useAccountsInternal = createDataHook({
+  model: "Account",
+  dataPropertyName: "accounts",
+  // Include brands relationship for brand display
+  selectionSet: [
+    "id",
+    "name",
+    "logo",
+    "subscription",
+    "settings",
+    "status",
+    "deletedAt",
+    "deletedBy",
+    "brands.id",
+    "brands.name",
+    "brands.status"
+  ],
+  transform: transformAccount
+});
+function useAccounts(options = {}) {
+  const result = useAccountsInternal(options);
+  return {
+    accounts: result.accounts,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch
+  };
+}
+
+// src/hooks/accounts/usePaginatedAccounts.ts
+function transformAccount2(account) {
+  const brands = account.brands || [];
+  return {
+    ...account,
+    brands,
+    brandCount: brands.length
+  };
+}
+var ACCOUNT_SELECTION_SET = [
+  "id",
+  "name",
+  "logo",
+  "subscription",
+  "settings",
+  "status",
+  "deletedAt",
+  "deletedBy",
+  "brands.id",
+  "brands.name",
+  "brands.status"
+];
+var useActiveAccountsInternal = createPaginatedDataHook({
+  model: "Account",
+  dataPropertyName: "accounts",
+  defaultPageSize: 25,
+  selectionSet: ACCOUNT_SELECTION_SET,
+  transform: transformAccount2,
+  baseFilter: ACTIVE_FILTER
+});
+var useDeletedAccountsInternal = createPaginatedDataHook({
+  model: "Account",
+  dataPropertyName: "accounts",
+  defaultPageSize: 25,
+  selectionSet: ACCOUNT_SELECTION_SET,
+  transform: transformAccount2,
+  baseFilter: DELETED_FILTER
+});
+function useActiveAccounts(options = {}) {
+  const result = useActiveAccountsInternal(options);
+  return {
+    accounts: result.accounts,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+function useDeletedAccounts(options = {}) {
+  const result = useDeletedAccountsInternal(options);
+  return {
+    accounts: result.accounts,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+
+// src/hooks/reservations/useReservations.ts
+function buildFilter5(options) {
+  const conditions = [];
+  if (options.brandId) {
+    conditions.push({ brandId: { eq: options.brandId } });
+  }
+  if (options.status) {
+    conditions.push({ status: { eq: options.status } });
+  }
+  if (options.contactId) {
+    conditions.push({ visitId: { eq: options.contactId } });
+  }
+  if (options.startDate) {
+    conditions.push({ checkIn: { ge: options.startDate } });
+  }
+  if (options.endDate) {
+    conditions.push({ checkIn: { le: options.endDate } });
+  }
+  if (options.filter) {
+    conditions.push(options.filter);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+function transformReservation(r) {
+  let snapshot = r.visit?.snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      snapshot = JSON.parse(snapshot);
+    } catch {
+      snapshot = null;
+    }
+  }
+  return {
+    ...r,
+    brandName: r.brand?.name || "Unknown Brand",
+    guestName: snapshot ? `${snapshot.firstName || ""} ${snapshot.lastName || ""}`.trim() || "Unknown Guest" : "Unknown Guest",
+    guestEmail: snapshot?.email || "",
+    guestPhone: snapshot?.phone || ""
+  };
+}
+var useReservationsInternal = createDataHook({
+  model: "Reservation",
+  dataPropertyName: "reservations",
+  buildFilter: buildFilter5,
+  // Include related data for brand name and guest info
+  selectionSet: [
+    "id",
+    "brandId",
+    "visitId",
+    "checkIn",
+    "checkOut",
+    "room",
+    "roomType",
+    "status",
+    "source",
+    "channel",
+    "confirmationCode",
+    "totalAmount",
+    "currency",
+    "nights",
+    "deletedAt",
+    "deletedBy",
+    "brand.name",
+    "visit.snapshot"
+  ],
+  transform: transformReservation,
+  computedProperties: {
+    confirmedReservations: (reservations) => reservations.filter((r) => r.status === "confirmed"),
+    activeReservations: (reservations) => reservations.filter((r) => r.status === "confirmed" || r.status === "checked_in")
+  }
+});
+function useReservations(options = {}) {
+  const result = useReservationsInternal(options);
+  return {
+    reservations: result.reservations,
+    confirmedReservations: result.confirmedReservations,
+    activeReservations: result.activeReservations,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch
+  };
+}
+
+// src/hooks/reservations/usePaginatedReservations.ts
+function buildFilter6(options) {
+  const conditions = [];
+  if (options.brandId) {
+    conditions.push({ brandId: { eq: options.brandId } });
+  }
+  if (options.status) {
+    conditions.push({ status: { eq: options.status } });
+  }
+  if (options.contactId) {
+    conditions.push({ visitId: { eq: options.contactId } });
+  }
+  if (options.startDate) {
+    conditions.push({ checkIn: { ge: options.startDate } });
+  }
+  if (options.endDate) {
+    conditions.push({ checkIn: { le: options.endDate } });
+  }
+  if (options.filter && Object.keys(options.filter).length > 0) {
+    conditions.push(options.filter);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+function transformReservation2(r) {
+  let snapshot = r.visit?.snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      snapshot = JSON.parse(snapshot);
+    } catch {
+      snapshot = null;
+    }
+  }
+  return {
+    ...r,
+    brandName: r.brand?.name || "Unknown Brand",
+    guestName: snapshot ? `${snapshot.firstName || ""} ${snapshot.lastName || ""}`.trim() || "Unknown Guest" : "Unknown Guest",
+    guestEmail: snapshot?.email || "",
+    guestPhone: snapshot?.phone || ""
+  };
+}
+var RESERVATION_SELECTION_SET = [
+  "id",
+  "brandId",
+  "visitId",
+  "checkIn",
+  "checkOut",
+  "room",
+  "roomType",
+  "status",
+  "source",
+  "channel",
+  "confirmationCode",
+  "totalAmount",
+  "currency",
+  "nights",
+  "deletedAt",
+  "deletedBy",
+  "brand.name",
+  "visit.snapshot"
+];
+var useActiveReservationsInternal = createPaginatedDataHook({
+  model: "Reservation",
+  dataPropertyName: "reservations",
+  defaultPageSize: 25,
+  selectionSet: RESERVATION_SELECTION_SET,
+  transform: transformReservation2,
+  buildFilter: buildFilter6,
+  baseFilter: ACTIVE_FILTER
+});
+var useDeletedReservationsInternal = createPaginatedDataHook({
+  model: "Reservation",
+  dataPropertyName: "reservations",
+  defaultPageSize: 25,
+  selectionSet: RESERVATION_SELECTION_SET,
+  transform: transformReservation2,
+  buildFilter: buildFilter6,
+  baseFilter: DELETED_FILTER
+});
+function useActiveReservations(options = {}) {
+  const result = useActiveReservationsInternal(options);
+  return {
+    reservations: result.reservations,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+function useDeletedReservations(options = {}) {
+  const result = useDeletedReservationsInternal(options);
+  return {
+    reservations: result.reservations,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+
+// src/hooks/products/useProducts.ts
+function buildFilter7(options) {
   let filter = options.filter || {};
   if (options.activeOnly) {
     filter = { ...filter, isActive: { eq: true } };
@@ -208,7 +856,7 @@ function buildFilter3(options) {
 var useProductsInternal = createDataHook({
   model: "Product",
   dataPropertyName: "products",
-  buildFilter: buildFilter3,
+  buildFilter: buildFilter7,
   computedProperties: {
     activeProducts: (products) => products.filter((p) => p.isActive === true)
   }
@@ -397,8 +1045,8 @@ async function toggleProductInstanceEnabled(client, id, enabled) {
   }
 }
 
-// src/hooks/useProductInstances.ts
-function buildFilter4(options) {
+// src/hooks/productInstances/useProductInstances.ts
+function buildFilter8(options) {
   let filter = options.filter || {};
   if (options.brandId) {
     filter = { ...filter, brandId: { eq: options.brandId } };
@@ -417,7 +1065,7 @@ function buildFilter4(options) {
 var useProductInstancesInternal = createDataHook({
   model: "ProductInstance",
   dataPropertyName: "instances",
-  buildFilter: buildFilter4,
+  buildFilter: buildFilter8,
   computedProperties: {
     enabledInstances: (instances) => instances.filter((i) => i.enabled)
   }
@@ -465,23 +1113,32 @@ function useProductInstances(options = {}) {
   };
 }
 
-// src/hooks/useReservations.ts
-function buildFilter5(options) {
+// src/hooks/contacts/useContacts.ts
+function buildFilter9(options) {
   const conditions = [];
   if (options.brandId) {
     conditions.push({ brandId: { eq: options.brandId } });
   }
-  if (options.status) {
-    conditions.push({ status: { eq: options.status } });
+  if (options.search) {
+    conditions.push({
+      or: [
+        { email: { contains: options.search } },
+        { firstName: { contains: options.search } },
+        { lastName: { contains: options.search } }
+      ]
+    });
   }
-  if (options.contactId) {
-    conditions.push({ visitId: { eq: options.contactId } });
+  if (options.gdprConsent !== void 0) {
+    conditions.push({ gdprConsent: { eq: options.gdprConsent } });
   }
-  if (options.startDate) {
-    conditions.push({ checkIn: { ge: options.startDate } });
+  if (options.marketingOptIn !== void 0) {
+    conditions.push({ marketingOptIn: { eq: options.marketingOptIn } });
   }
-  if (options.endDate) {
-    conditions.push({ checkIn: { le: options.endDate } });
+  if (options.tags && options.tags.length > 0) {
+    const tagConditions = options.tags.map((tag) => ({
+      tags: { contains: tag }
+    }));
+    conditions.push({ or: tagConditions });
   }
   if (options.filter) {
     conditions.push(options.filter);
@@ -494,33 +1151,36 @@ function buildFilter5(options) {
   }
   return { and: conditions };
 }
-var useReservationsInternal = createDataHook({
-  model: "Reservation",
-  dataPropertyName: "reservations",
-  buildFilter: buildFilter5,
+var useContactsInternal = createDataHook({
+  model: "Contact",
+  dataPropertyName: "contacts",
+  buildFilter: buildFilter9,
   computedProperties: {
-    confirmedReservations: (reservations) => reservations.filter((r) => r.status === "confirmed"),
-    activeReservations: (reservations) => reservations.filter((r) => r.status === "confirmed" || r.status === "checked_in")
+    consentedContacts: (contacts) => contacts.filter((c) => c.gdprConsent === true),
+    marketingContacts: (contacts) => contacts.filter((c) => c.marketingOptIn === true)
   }
 });
-function useReservations(options = {}) {
-  const result = useReservationsInternal(options);
+function useContacts(options = {}) {
+  const result = useContactsInternal(options);
   return {
-    reservations: result.reservations,
-    confirmedReservations: result.confirmedReservations,
-    activeReservations: result.activeReservations,
+    contacts: result.contacts,
+    consentedContacts: result.consentedContacts,
+    marketingContacts: result.marketingContacts,
     loading: result.loading,
     error: result.error,
     refetch: result.refetch
   };
 }
 
-// src/hooks/useContacts.ts
-function buildFilter6(options) {
+// src/hooks/contacts/usePaginatedContacts.ts
+function buildFilter10(options) {
   const conditions = [];
   if (options.brandId) {
     conditions.push({ brandId: { eq: options.brandId } });
   }
+  if (options.accountId) {
+    conditions.push({ accountId: { eq: options.accountId } });
+  }
   if (options.search) {
     conditions.push({
       or: [
@@ -542,7 +1202,7 @@ function buildFilter6(options) {
     }));
     conditions.push({ or: tagConditions });
   }
-  if (options.filter) {
+  if (options.filter && Object.keys(options.filter).length > 0) {
     conditions.push(options.filter);
   }
   if (conditions.length === 0) {
@@ -553,32 +1213,109 @@ function buildFilter6(options) {
   }
   return { and: conditions };
 }
-var useContactsInternal = createDataHook({
+function transformContact(contact) {
+  return {
+    ...contact,
+    name: `${contact.firstName || ""} ${contact.lastName || ""}`.trim() || contact.email,
+    brandName: contact.brand?.name || ""
+  };
+}
+var CONTACT_SELECTION_SET = [
+  "id",
+  "email",
+  "phone",
+  "firstName",
+  "lastName",
+  "locale",
+  "brandId",
+  "accountId",
+  "gdprConsent",
+  "gdprConsentDate",
+  "marketingOptIn",
+  "preferences",
+  "tags",
+  "totalVisits",
+  "lastVisitDate",
+  "firstVisitDate",
+  "source",
+  "status",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "deletedBy",
+  "brand.name"
+];
+var useActiveContactsInternal = createPaginatedDataHook({
   model: "Contact",
   dataPropertyName: "contacts",
-  buildFilter: buildFilter6,
-  computedProperties: {
-    consentedContacts: (contacts) => contacts.filter((c) => c.gdprConsent === true),
-    marketingContacts: (contacts) => contacts.filter((c) => c.marketingOptIn === true)
-  }
+  defaultPageSize: 25,
+  selectionSet: CONTACT_SELECTION_SET,
+  transform: transformContact,
+  buildFilter: buildFilter10,
+  baseFilter: ACTIVE_FILTER
 });
-function useContacts(options = {}) {
-  const result = useContactsInternal(options);
+var useDeletedContactsInternal = createPaginatedDataHook({
+  model: "Contact",
+  dataPropertyName: "contacts",
+  defaultPageSize: 25,
+  selectionSet: CONTACT_SELECTION_SET,
+  transform: transformContact,
+  buildFilter: buildFilter10,
+  baseFilter: DELETED_FILTER
+});
+function useActiveContacts(options = {}) {
+  const result = useActiveContactsInternal(options);
   return {
     contacts: result.contacts,
-    consentedContacts: result.consentedContacts,
-    marketingContacts: result.marketingContacts,
     loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
     error: result.error,
-    refetch: result.refetch
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
+  };
+}
+function useDeletedContacts(options = {}) {
+  const result = useDeletedContactsInternal(options);
+  return {
+    contacts: result.contacts,
+    loading: result.loading,
+    initialLoading: result.initialLoading,
+    loadingMore: result.loadingMore,
+    error: result.error,
+    pagination: result.pagination,
+    hasMore: result.hasMore,
+    loadMore: result.loadMore,
+    refetch: result.refetch,
+    reset: result.reset,
+    setSearchFilter: result.setSearchFilter,
+    searchFilter: result.searchFilter
   };
 }
 export {
+  ACTIVE_FILTER,
+  DELETED_FILTER,
   createDataHook,
+  createPaginatedDataHook,
   resetClientInstance,
   useAccounts,
+  useActiveAccounts,
+  useActiveBrands,
+  useActiveContacts,
+  useActiveReservations,
+  useActiveUsers,
   useBrands,
   useContacts,
+  useDeletedAccounts,
+  useDeletedBrands,
+  useDeletedContacts,
+  useDeletedReservations,
+  useDeletedUsers,
   useProductInstances,
   useProducts,
   useReservations,