@htlkg/data 0.0.20 → 0.0.22

package/dist/index.js

@@ -77,7 +77,7 @@ function generateServerClient(_options) {
   return client;
 }
 
-// src/queries/brands.ts
+// src/queries/brands/brands.ts
 async function getBrand(client, id) {
   try {
     const { data, errors } = await client.models.Brand.get({ id });
@@ -149,7 +149,7 @@ async function listActiveBrands(client, options) {
   });
 }
 
-// src/queries/accounts.ts
+// src/queries/accounts/accounts.ts
 async function getAccount(client, id) {
   try {
     const { data, errors } = await client.models.Account.get({ id });
@@ -205,7 +205,7 @@ async function getAccountWithBrands(client, id) {
   }
 }
 
-// src/queries/users.ts
+// src/queries/users/users.ts
 async function getUser(client, id) {
   try {
     const { data, errors } = await client.models.User.get({ id });
@@ -282,7 +282,7 @@ async function listActiveUsers(client, options) {
   });
 }
 
-// src/queries/products.ts
+// src/queries/products/products.ts
 async function getProduct(client, id) {
   try {
     const { data, errors } = await client.models.Product.get({ id });
@@ -487,7 +487,7 @@ function checkRestoreEligibility(deletedAt, retentionDays) {
   };
 }
 
-// src/queries/reservations.ts
+// src/queries/reservations/reservations.ts
 async function getReservation2(client, id) {
   try {
     const { data, errors } = await client.models.Reservation.get({ id });
@@ -563,7 +563,110 @@ async function getReservationByConfirmation(client, confirmationCode, brandId) {
   }
 }
 
-// src/mutations/brands.ts
+// src/queries/contacts.ts
+async function getContact(client, id) {
+  try {
+    const { data, errors } = await client.models.Contact.get({ id });
+    if (errors) {
+      console.error("[getContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getContact] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function listContacts(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Contact.list(options);
+    if (errors) {
+      console.error("[listContacts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listContacts] Error fetching contacts:", error);
+    throw error;
+  }
+}
+async function listContactsByBrand(client, brandId, options) {
+  return listContacts(client, {
+    filter: { brandId: { eq: brandId } },
+    ...options
+  });
+}
+async function getContactByEmail(client, email, brandId) {
+  try {
+    const { data, errors } = await client.models.Contact.list({
+      filter: {
+        and: [{ email: { eq: email } }, { brandId: { eq: brandId } }]
+      },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getContactByEmail] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getContactByEmail] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function getContactByPhone(client, phone, brandId) {
+  try {
+    const { data, errors } = await client.models.Contact.list({
+      filter: {
+        and: [{ phone: { eq: phone } }, { brandId: { eq: brandId } }]
+      },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getContactByPhone] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getContactByPhone] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function searchContacts(client, query2, brandId, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Contact.list({
+      filter: {
+        and: [
+          { brandId: { eq: brandId } },
+          {
+            or: [
+              { email: { contains: query2 } },
+              { firstName: { contains: query2 } },
+              { lastName: { contains: query2 } }
+            ]
+          }
+        ]
+      },
+      ...options
+    });
+    if (errors) {
+      console.error("[searchContacts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[searchContacts] Error searching contacts:", error);
+    throw error;
+  }
+}
+
+// src/mutations/brands/brands.ts
 async function createBrand(client, input) {
   try {
     const { data, errors } = await client.models.Brand.create(input);
@@ -651,7 +754,7 @@ async function deleteBrand(client, id) {
   }
 }
 
-// src/mutations/accounts.ts
+// src/mutations/accounts/accounts.ts
 async function createAccount(client, input) {
   try {
     const { data, errors } = await client.models.Account.create(input);
@@ -739,7 +842,7 @@ async function deleteAccount(client, id) {
   }
 }
 
-// src/mutations/users.ts
+// src/mutations/users/users.ts
 async function createUser(client, input) {
   try {
     const { data, errors } = await client.models.User.create(input);
@@ -1041,7 +1144,7 @@ async function initializeSystemSettings(client, initializedBy) {
   }
 }
 
-// src/mutations/reservations.ts
+// src/mutations/reservations/reservations.ts
 var STATUS_TRANSITIONS = {
   confirmed: ["checked_in", "cancelled", "no_show"],
   checked_in: ["checked_out", "cancelled"],
@@ -1234,6 +1337,265 @@ async function updateReservationStatus2(client, id, newStatus) {
   }
 }
 
+// src/mutations/contacts.ts
+import { z } from "zod";
+var createContactSchema = z.object({
+  brandId: z.string().min(1, "Brand ID is required"),
+  email: z.string().email("Invalid email address"),
+  phone: z.string().optional(),
+  firstName: z.string().min(1, "First name is required"),
+  lastName: z.string().min(1, "Last name is required"),
+  locale: z.string().optional(),
+  gdprConsent: z.boolean(),
+  gdprConsentDate: z.string().optional(),
+  marketingOptIn: z.boolean().optional(),
+  preferences: z.record(z.any()).optional(),
+  tags: z.array(z.string()).optional(),
+  totalVisits: z.number().int().min(0).optional(),
+  lastVisitDate: z.string().optional(),
+  firstVisitDate: z.string().optional(),
+  legacyId: z.string().optional(),
+  // Audit fields
+  createdAt: z.string().optional(),
+  createdBy: z.string().optional(),
+  updatedAt: z.string().optional(),
+  updatedBy: z.string().optional()
+});
+var updateContactSchema = z.object({
+  id: z.string().min(1, "Contact ID is required"),
+  brandId: z.string().min(1).optional(),
+  email: z.string().email("Invalid email address").optional(),
+  phone: z.string().optional(),
+  firstName: z.string().min(1).optional(),
+  lastName: z.string().min(1).optional(),
+  locale: z.string().optional(),
+  gdprConsent: z.boolean().optional(),
+  gdprConsentDate: z.string().optional(),
+  marketingOptIn: z.boolean().optional(),
+  preferences: z.record(z.any()).optional(),
+  tags: z.array(z.string()).optional(),
+  totalVisits: z.number().int().min(0).optional(),
+  lastVisitDate: z.string().optional(),
+  firstVisitDate: z.string().optional(),
+  legacyId: z.string().optional(),
+  // Audit fields
+  updatedAt: z.string().optional(),
+  updatedBy: z.string().optional(),
+  deletedAt: z.string().nullable().optional(),
+  deletedBy: z.string().nullable().optional()
+});
+var mergeContactsSchema = z.object({
+  primaryId: z.string().min(1, "Primary contact ID is required"),
+  duplicateIds: z.array(z.string().min(1)).min(1, "At least one duplicate ID is required")
+});
+var ContactValidationError = class extends Error {
+  issues;
+  constructor(message, issues = []) {
+    super(message);
+    this.name = "ContactValidationError";
+    this.issues = issues;
+  }
+};
+async function createContact(client, input) {
+  try {
+    const validationResult = createContactSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { data, errors } = await client.models.Contact.create(input);
+    if (errors) {
+      console.error("[createContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[createContact] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[createContact] Error creating contact:", error);
+    throw error;
+  }
+}
+async function updateContact(client, input) {
+  try {
+    const validationResult = updateContactSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { data, errors } = await client.models.Contact.update(input);
+    if (errors) {
+      console.error("[updateContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[updateContact] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateContact] Error updating contact:", error);
+    throw error;
+  }
+}
+async function softDeleteContact(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Contact.update({
+      id,
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteContact] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteContact] Error soft-deleting contact:", error);
+    throw error;
+  }
+}
+async function restoreContact(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const contact = await getContact(client, id);
+    if (!contact) {
+      console.error("[restoreContact] Contact not found");
+      return { success: false, error: "Contact not found" };
+    }
+    const eligibility = checkRestoreEligibility(
+      contact.deletedAt,
+      retentionDays
+    );
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore contact. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreContact]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Contact.update({
+      id,
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreContact] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore contact" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreContact] Error restoring contact:", error);
+    throw error;
+  }
+}
+async function deleteContact(client, id) {
+  try {
+    const { errors } = await client.models.Contact.delete({ id });
+    if (errors) {
+      console.error("[deleteContact] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteContact] Error deleting contact:", error);
+    throw error;
+  }
+}
+async function mergeContacts(client, input, mergedBy) {
+  try {
+    const validationResult = mergeContactsSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { primaryId, duplicateIds } = input;
+    const primaryContact = await getContact(client, primaryId);
+    if (!primaryContact) {
+      return {
+        success: false,
+        error: `Primary contact not found: ${primaryId}`
+      };
+    }
+    const duplicateContacts = [];
+    for (const duplicateId of duplicateIds) {
+      const duplicate = await getContact(client, duplicateId);
+      if (!duplicate) {
+        return {
+          success: false,
+          error: `Duplicate contact not found: ${duplicateId}`
+        };
+      }
+      duplicateContacts.push(duplicate);
+    }
+    let totalVisits = primaryContact.totalVisits || 0;
+    let firstVisitDate = primaryContact.firstVisitDate;
+    let lastVisitDate = primaryContact.lastVisitDate;
+    const allTags = new Set(primaryContact.tags || []);
+    for (const duplicate of duplicateContacts) {
+      totalVisits += duplicate.totalVisits || 0;
+      if (duplicate.firstVisitDate) {
+        if (!firstVisitDate || duplicate.firstVisitDate < firstVisitDate) {
+          firstVisitDate = duplicate.firstVisitDate;
+        }
+      }
+      if (duplicate.lastVisitDate) {
+        if (!lastVisitDate || duplicate.lastVisitDate > lastVisitDate) {
+          lastVisitDate = duplicate.lastVisitDate;
+        }
+      }
+      if (duplicate.tags) {
+        duplicate.tags.forEach((tag) => allTags.add(tag));
+      }
+    }
+    const updateInput = {
+      id: primaryId,
+      totalVisits,
+      firstVisitDate,
+      lastVisitDate,
+      tags: Array.from(allTags),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: mergedBy
+    };
+    const updatedPrimary = await updateContact(client, updateInput);
+    if (!updatedPrimary) {
+      return {
+        success: false,
+        error: "Failed to update primary contact with merged data"
+      };
+    }
+    const deletedIds = [];
+    for (const duplicateId of duplicateIds) {
+      const deleted = await softDeleteContact(client, duplicateId, mergedBy);
+      if (deleted) {
+        deletedIds.push(duplicateId);
+      } else {
+        console.error(`[mergeContacts] Failed to soft-delete duplicate: ${duplicateId}`);
+      }
+    }
+    return {
+      success: true,
+      mergedContact: updatedPrimary,
+      deletedIds
+    };
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[mergeContacts] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[mergeContacts] Error merging contacts:", error);
+    throw error;
+  }
+}
+
 // src/hooks/createDataHook.ts
 import { ref, computed, onMounted } from "vue";
 function resetClientInstance() {
@@ -1244,7 +1606,7 @@ function createDataHook(config) {
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter6,
+    buildFilter: buildFilter10,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -1254,8 +1616,8 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter6) {
-        return buildFilter6(options);
+      if (buildFilter10) {
+        return buildFilter10(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
@@ -1315,7 +1677,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: buildFilter10,
+    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 (buildFilter10) {
+        const customFilter = buildFilter10(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) {
@@ -1345,23 +1871,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 } };
@@ -1374,7 +1973,7 @@ function buildFilter2(options) {
 var useUsersInternal = createDataHook({
   model: "User",
   dataPropertyName: "users",
-  buildFilter: buildFilter2
+  buildFilter: buildFilter3
 });
 function useUsers(options = {}) {
   const result = useUsersInternal(options);
@@ -1386,8 +1985,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 } };
@@ -1397,7 +2407,7 @@ function buildFilter3(options) {
 var useProductsInternal = createDataHook({
   model: "Product",
   dataPropertyName: "products",
-  buildFilter: buildFilter3,
+  buildFilter: buildFilter7,
   computedProperties: {
     activeProducts: (products) => products.filter((p) => p.isActive === true)
   }
@@ -1413,8 +2423,8 @@ function useProducts(options = {}) {
   };
 }
 
-// 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 } };
@@ -1433,7 +2443,7 @@ function buildFilter4(options) {
 var useProductInstancesInternal = createDataHook({
   model: "ProductInstance",
   dataPropertyName: "instances",
-  buildFilter: buildFilter4,
+  buildFilter: buildFilter8,
   computedProperties: {
     enabledInstances: (instances) => instances.filter((i) => i.enabled)
   }
@@ -1481,23 +2491,32 @@ function useProductInstances(options = {}) {
   };
 }
 
-// src/hooks/useReservations.ts
-function buildFilter5(options) {
+// src/hooks/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);
@@ -1510,21 +2529,21 @@ 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
@@ -1634,13 +2653,19 @@ function createSingleStore(shared, name, defaultValue) {
   return shared(name, atom(defaultValue));
 }
 export {
+  ACTIVE_FILTER,
+  ContactValidationError,
   DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+  DELETED_FILTER,
   ReservationValidationError,
   SYSTEM_SETTINGS_KEY,
   checkRestoreEligibility,
   createAccount,
   createBrand,
+  createContact,
+  createContactSchema,
   createDataHook,
+  createPaginatedDataHook,
   createProductInstance,
   createReservation2 as createReservation,
   createResourceStores,
@@ -1649,6 +2674,7 @@ export {
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteContact,
   deleteProductInstance,
   deleteReservation2 as deleteReservation,
   deleteUser,
@@ -1660,6 +2686,9 @@ export {
   getAccountWithBrands,
   getBrand,
   getBrandWithProducts,
+  getContact,
+  getContactByEmail,
+  getContactByPhone,
   getErrorMessage,
   getProduct,
   getProductInstance,
@@ -1679,6 +2708,8 @@ export {
   listActiveUsers,
   listBrands,
   listBrandsByAccount,
+  listContacts,
+  listContactsByBrand,
   listEnabledProductInstancesByBrand,
   listProductInstancesByAccount,
   listProductInstancesByBrand,
@@ -1689,28 +2720,44 @@ export {
   listReservationsByDateRange,
   listUsers,
   listUsersByAccount,
+  mergeContacts,
+  mergeContactsSchema,
   mutate,
   query,
   resetClientInstance,
   resetSharedClient,
   restoreAccount,
   restoreBrand,
+  restoreContact,
   restoreReservation2 as restoreReservation,
   restoreUser,
+  searchContacts,
   softDeleteAccount,
   softDeleteBrand,
+  softDeleteContact,
   softDeleteReservation2 as softDeleteReservation,
   softDeleteUser,
   toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateContact,
+  updateContactSchema,
   updateProductInstance,
   updateReservation2 as updateReservation,
   updateReservationStatus2 as updateReservationStatus,
   updateSystemSettings,
   updateUser,
   useAccounts,
+  useActiveAccounts,
+  useActiveBrands,
+  useActiveReservations,
+  useActiveUsers,
   useBrands,
+  useContacts,
+  useDeletedAccounts,
+  useDeletedBrands,
+  useDeletedReservations,
+  useDeletedUsers,
   useProductInstances,
   useProducts,
   useReservations,