@htlkg/data 0.0.19 → 0.0.21

package/dist/index.js

@@ -487,6 +487,185 @@ function checkRestoreEligibility(deletedAt, retentionDays) {
   };
 }
 
+// src/queries/reservations.ts
+async function getReservation2(client, id) {
+  try {
+    const { data, errors } = await client.models.Reservation.get({ id });
+    if (errors) {
+      console.error("[getReservation] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getReservation] Error fetching reservation:", error);
+    throw error;
+  }
+}
+async function listReservations2(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Reservation.list(
+      options
+    );
+    if (errors) {
+      console.error("[listReservations] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listReservations] Error fetching reservations:", error);
+    throw error;
+  }
+}
+async function listReservationsByBrand(client, brandId, options) {
+  const filter = options?.filter ? { and: [{ brandId: { eq: brandId } }, options.filter] } : { brandId: { eq: brandId } };
+  return listReservations2(client, {
+    filter,
+    limit: options?.limit,
+    nextToken: options?.nextToken
+  });
+}
+async function listReservationsByContact(client, contactId, options) {
+  return listReservations2(client, {
+    filter: { visitId: { eq: contactId } },
+    ...options
+  });
+}
+async function listReservationsByDateRange(client, brandId, startDate, endDate, options) {
+  return listReservations2(client, {
+    filter: {
+      and: [
+        { brandId: { eq: brandId } },
+        { checkIn: { ge: startDate } },
+        { checkIn: { le: endDate } }
+      ]
+    },
+    ...options
+  });
+}
+async function getReservationByConfirmation(client, confirmationCode, brandId) {
+  try {
+    const { items } = await listReservations2(client, {
+      filter: {
+        and: [
+          { confirmationCode: { eq: confirmationCode } },
+          { brandId: { eq: brandId } }
+        ]
+      },
+      limit: 1
+    });
+    return items.length > 0 ? items[0] : null;
+  } catch (error) {
+    console.error("[getReservationByConfirmation] Error fetching reservation:", error);
+    throw error;
+  }
+}
+
+// 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.ts
 async function createBrand(client, input) {
   try {
@@ -965,15 +1144,469 @@ async function initializeSystemSettings(client, initializedBy) {
   }
 }
 
+// src/mutations/reservations.ts
+var STATUS_TRANSITIONS = {
+  confirmed: ["checked_in", "cancelled", "no_show"],
+  checked_in: ["checked_out", "cancelled"],
+  checked_out: [],
+  // Terminal state - no transitions allowed
+  cancelled: [],
+  // Terminal state - no transitions allowed
+  no_show: []
+  // Terminal state - no transitions allowed
+};
+var ReservationValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReservationValidationError";
+  }
+};
+function validateDates(checkIn, checkOut) {
+  const checkInDate = new Date(checkIn);
+  const checkOutDate = new Date(checkOut);
+  if (isNaN(checkInDate.getTime())) {
+    throw new ReservationValidationError("Invalid check-in date");
+  }
+  if (isNaN(checkOutDate.getTime())) {
+    throw new ReservationValidationError("Invalid check-out date");
+  }
+  if (checkOutDate <= checkInDate) {
+    throw new ReservationValidationError(
+      "Check-out date must be after check-in date"
+    );
+  }
+  const minStayHours = 4;
+  const stayDuration = checkOutDate.getTime() - checkInDate.getTime();
+  const hoursDiff = stayDuration / (1e3 * 60 * 60);
+  if (hoursDiff < minStayHours) {
+    throw new ReservationValidationError(
+      `Minimum stay is ${minStayHours} hours`
+    );
+  }
+}
+function validateStatusTransition(currentStatus, newStatus) {
+  const allowedTransitions = STATUS_TRANSITIONS[currentStatus];
+  if (!allowedTransitions.includes(newStatus)) {
+    throw new ReservationValidationError(
+      `Invalid status transition from '${currentStatus}' to '${newStatus}'. Allowed transitions: ${allowedTransitions.length > 0 ? allowedTransitions.join(", ") : "none (terminal state)"}`
+    );
+  }
+}
+async function createReservation2(client, input) {
+  try {
+    validateDates(input.checkIn, input.checkOut);
+    if (!input.nights) {
+      const checkInDate = new Date(input.checkIn);
+      const checkOutDate = new Date(input.checkOut);
+      const diffTime = checkOutDate.getTime() - checkInDate.getTime();
+      const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+      input.nights = diffDays;
+    }
+    const { data, errors } = await client.models.Reservation.create(input);
+    if (errors) {
+      console.error("[createReservation] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[createReservation] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[createReservation] Error creating reservation:", error);
+    throw error;
+  }
+}
+async function updateReservation2(client, input) {
+  try {
+    if (input.checkIn && input.checkOut) {
+      validateDates(input.checkIn, input.checkOut);
+      const checkInDate = new Date(input.checkIn);
+      const checkOutDate = new Date(input.checkOut);
+      const diffTime = checkOutDate.getTime() - checkInDate.getTime();
+      const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+      input.nights = diffDays;
+    }
+    if (input.status) {
+      const { data: currentReservation, errors: getErrors } = await client.models.Reservation.get({ id: input.id });
+      if (getErrors || !currentReservation) {
+        console.error("[updateReservation] Error fetching current reservation:", getErrors);
+        return null;
+      }
+      const currentStatus = currentReservation.status;
+      validateStatusTransition(currentStatus, input.status);
+    }
+    const { data, errors } = await client.models.Reservation.update(input);
+    if (errors) {
+      console.error("[updateReservation] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[updateReservation] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateReservation] Error updating reservation:", error);
+    throw error;
+  }
+}
+async function softDeleteReservation2(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Reservation.update({
+      id,
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteReservation] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteReservation] Error soft-deleting reservation:", error);
+    throw error;
+  }
+}
+async function restoreReservation2(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const { data: reservation, errors: getErrors } = await client.models.Reservation.get({ id });
+    if (getErrors || !reservation) {
+      console.error("[restoreReservation] Error fetching reservation:", getErrors);
+      return { success: false, error: "Reservation not found" };
+    }
+    const eligibility = checkRestoreEligibility(reservation.deletedAt, retentionDays);
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore reservation. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreReservation]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Reservation.update({
+      id,
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreReservation] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore reservation" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreReservation] Error restoring reservation:", error);
+    throw error;
+  }
+}
+async function deleteReservation2(client, id) {
+  try {
+    const { errors } = await client.models.Reservation.delete({ id });
+    if (errors) {
+      console.error("[deleteReservation] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteReservation] Error deleting reservation:", error);
+    throw error;
+  }
+}
+async function updateReservationStatus2(client, id, newStatus) {
+  try {
+    const { data: currentReservation, errors: getErrors } = await client.models.Reservation.get({ id });
+    if (getErrors || !currentReservation) {
+      console.error("[updateReservationStatus] Error fetching reservation:", getErrors);
+      return null;
+    }
+    const currentStatus = currentReservation.status;
+    validateStatusTransition(currentStatus, newStatus);
+    const { data, errors } = await client.models.Reservation.update({
+      id,
+      status: newStatus
+    });
+    if (errors) {
+      console.error("[updateReservationStatus] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[updateReservationStatus] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateReservationStatus] Error updating status:", error);
+    throw error;
+  }
+}
+
+// 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() {
+}
 function createDataHook(config) {
   const {
     model,
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter5,
+    buildFilter: buildFilter7,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -983,8 +1616,8 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter5) {
-        return buildFilter5(options);
+      if (buildFilter7) {
+        return buildFilter7(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
@@ -992,19 +1625,22 @@ function createDataHook(config) {
       loading.value = true;
       error.value = null;
       try {
-        const client = getSharedClient();
-        const queryOptions = {
-          filter: getFilter(),
-          limit
-        };
+        const queryOptions = {};
+        const filter = getFilter();
+        if (filter) {
+          queryOptions.filter = filter;
+        }
+        if (limit) {
+          queryOptions.limit = limit;
+        }
         if (selectionSet) {
           queryOptions.selectionSet = selectionSet;
         }
-        const { data: responseData, errors } = await client.models[model].list(queryOptions);
-        if (errors) {
-          throw new Error(errors[0]?.message || `Failed to fetch ${model}`);
+        const response = await query(model, "list", queryOptions);
+        if (hasErrors(response)) {
+          throw new Error(getErrorMessage(response) || `Failed to fetch ${model}`);
         }
-        const items = responseData || [];
+        const items = response.data || [];
         data.value = transform ? items.map(transform) : items;
       } catch (e) {
         error.value = e;
@@ -1207,6 +1843,115 @@ function useProductInstances(options = {}) {
   };
 }
 
+// src/hooks/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 };
+}
+var useReservationsInternal = createDataHook({
+  model: "Reservation",
+  dataPropertyName: "reservations",
+  buildFilter: buildFilter5,
+  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/useContacts.ts
+function buildFilter6(options) {
+  const conditions = [];
+  if (options.brandId) {
+    conditions.push({ brandId: { eq: options.brandId } });
+  }
+  if (options.search) {
+    conditions.push({
+      or: [
+        { email: { contains: options.search } },
+        { firstName: { contains: options.search } },
+        { lastName: { contains: options.search } }
+      ]
+    });
+  }
+  if (options.gdprConsent !== void 0) {
+    conditions.push({ gdprConsent: { eq: options.gdprConsent } });
+  }
+  if (options.marketingOptIn !== void 0) {
+    conditions.push({ marketingOptIn: { eq: options.marketingOptIn } });
+  }
+  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);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+var useContactsInternal = createDataHook({
+  model: "Contact",
+  dataPropertyName: "contacts",
+  buildFilter: buildFilter6,
+  computedProperties: {
+    consentedContacts: (contacts) => contacts.filter((c) => c.gdprConsent === true),
+    marketingContacts: (contacts) => contacts.filter((c) => c.marketingOptIn === true)
+  }
+});
+function useContacts(options = {}) {
+  const result = useContactsInternal(options);
+  return {
+    contacts: result.contacts,
+    consentedContacts: result.consentedContacts,
+    marketingContacts: result.marketingContacts,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch
+  };
+}
+
 // ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
 var clean = /* @__PURE__ */ Symbol("clean");
 
@@ -1310,20 +2055,27 @@ function createSingleStore(shared, name, defaultValue) {
   return shared(name, atom(defaultValue));
 }
 export {
+  ContactValidationError,
   DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+  ReservationValidationError,
   SYSTEM_SETTINGS_KEY,
   checkRestoreEligibility,
   createAccount,
   createBrand,
+  createContact,
+  createContactSchema,
   createDataHook,
   createProductInstance,
+  createReservation2 as createReservation,
   createResourceStores,
   createSingleStore,
   createStore,
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteContact,
   deleteProductInstance,
+  deleteReservation2 as deleteReservation,
   deleteUser,
   executePublicQuery,
   executeServerQuery,
@@ -1333,9 +2085,14 @@ export {
   getAccountWithBrands,
   getBrand,
   getBrandWithProducts,
+  getContact,
+  getContactByEmail,
+  getContactByPhone,
   getErrorMessage,
   getProduct,
   getProductInstance,
+  getReservation2 as getReservation,
+  getReservationByConfirmation,
   getSharedClient,
   getSoftDeleteRetentionDays,
   getSystemSettings,
@@ -1350,32 +2107,51 @@ export {
   listActiveUsers,
   listBrands,
   listBrandsByAccount,
+  listContacts,
+  listContactsByBrand,
   listEnabledProductInstancesByBrand,
   listProductInstancesByAccount,
   listProductInstancesByBrand,
   listProducts,
+  listReservations2 as listReservations,
+  listReservationsByBrand,
+  listReservationsByContact,
+  listReservationsByDateRange,
   listUsers,
   listUsersByAccount,
+  mergeContacts,
+  mergeContactsSchema,
   mutate,
   query,
-  resetSharedClient as resetClientInstance,
+  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,
   useBrands,
+  useContacts,
   useProductInstances,
   useProducts,
+  useReservations,
   useUsers
 };
 //# sourceMappingURL=index.js.map