@htlkg/data 0.0.20 → 0.0.21

package/dist/mutations/index.d.ts

@@ -1,8 +1,9 @@
 import { C as CreateAuditFields, a as UpdateWithSoftDeleteFields } from '../common-DSxswsZ3.js';
 export { S as SoftDeleteFields, U as UpdateAuditFields } from '../common-DSxswsZ3.js';
-import { Brand, Account, User, SystemSettings } from '@htlkg/core/types';
+import { Brand, Account, User, SystemSettings, Contact } from '@htlkg/core/types';
 export { C as CreateProductInstanceInput, U as UpdateProductInstanceInput, c as createProductInstance, d as deleteProductInstance, t as toggleProductInstanceEnabled, u as updateProductInstance } from '../productInstances-BpQv1oLS.js';
 export { C as CreateReservationInput, b as ReservationStatus, R as ReservationValidationError, U as UpdateReservationInput, c as createReservation, d as deleteReservation, r as restoreReservation, s as softDeleteReservation, u as updateReservation, a as updateReservationStatus } from '../reservations-CdDfkcZ_.js';
+import { z } from 'zod';
 
 /**
  * Brand Mutation Functions
@@ -377,4 +378,339 @@ declare function updateSystemSettings<TClient = any>(client: TClient, input: Upd
  */
 declare function initializeSystemSettings<TClient = any>(client: TClient, initializedBy: string): Promise<SystemSettings | null>;
 
-export { type CreateAccountInput, CreateAuditFields, type CreateBrandInput, type CreateUserInput, type UpdateAccountInput, type UpdateBrandInput, type UpdateSystemSettingsInput, type UpdateUserInput, UpdateWithSoftDeleteFields, createAccount, createBrand, createUser, deleteAccount, deleteBrand, deleteUser, initializeSystemSettings, restoreAccount, restoreBrand, restoreUser, softDeleteAccount, softDeleteBrand, softDeleteUser, updateAccount, updateBrand, updateSystemSettings, updateUser };
+/**
+ * Contact Mutation Functions
+ *
+ * Provides type-safe mutation functions for creating, updating, and deleting contacts.
+ * Includes Zod validation for input data before mutations.
+ */
+
+/**
+ * Zod schema for creating a contact
+ */
+declare const createContactSchema: z.ZodObject<{
+    brandId: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    gdprConsent: z.ZodBoolean;
+    gdprConsentDate: z.ZodOptional<z.ZodString>;
+    marketingOptIn: z.ZodOptional<z.ZodBoolean>;
+    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    totalVisits: z.ZodOptional<z.ZodNumber>;
+    lastVisitDate: z.ZodOptional<z.ZodString>;
+    firstVisitDate: z.ZodOptional<z.ZodString>;
+    legacyId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    brandId: string;
+    email: string;
+    lastName: string;
+    firstName: string;
+    gdprConsent: boolean;
+    updatedAt?: string | undefined;
+    updatedBy?: string | undefined;
+    phone?: string | undefined;
+    locale?: string | undefined;
+    gdprConsentDate?: string | undefined;
+    marketingOptIn?: boolean | undefined;
+    preferences?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    totalVisits?: number | undefined;
+    lastVisitDate?: string | undefined;
+    firstVisitDate?: string | undefined;
+    legacyId?: string | undefined;
+    createdAt?: string | undefined;
+    createdBy?: string | undefined;
+}, {
+    brandId: string;
+    email: string;
+    lastName: string;
+    firstName: string;
+    gdprConsent: boolean;
+    updatedAt?: string | undefined;
+    updatedBy?: string | undefined;
+    phone?: string | undefined;
+    locale?: string | undefined;
+    gdprConsentDate?: string | undefined;
+    marketingOptIn?: boolean | undefined;
+    preferences?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    totalVisits?: number | undefined;
+    lastVisitDate?: string | undefined;
+    firstVisitDate?: string | undefined;
+    legacyId?: string | undefined;
+    createdAt?: string | undefined;
+    createdBy?: string | undefined;
+}>;
+/**
+ * Zod schema for updating a contact
+ */
+declare const updateContactSchema: z.ZodObject<{
+    id: z.ZodString;
+    brandId: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    gdprConsent: z.ZodOptional<z.ZodBoolean>;
+    gdprConsentDate: z.ZodOptional<z.ZodString>;
+    marketingOptIn: z.ZodOptional<z.ZodBoolean>;
+    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    totalVisits: z.ZodOptional<z.ZodNumber>;
+    lastVisitDate: z.ZodOptional<z.ZodString>;
+    firstVisitDate: z.ZodOptional<z.ZodString>;
+    legacyId: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+    deletedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    deletedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    updatedAt?: string | undefined;
+    updatedBy?: string | undefined;
+    brandId?: string | undefined;
+    deletedAt?: string | null | undefined;
+    deletedBy?: string | null | undefined;
+    email?: string | undefined;
+    phone?: string | undefined;
+    lastName?: string | undefined;
+    firstName?: string | undefined;
+    locale?: string | undefined;
+    gdprConsent?: boolean | undefined;
+    gdprConsentDate?: string | undefined;
+    marketingOptIn?: boolean | undefined;
+    preferences?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    totalVisits?: number | undefined;
+    lastVisitDate?: string | undefined;
+    firstVisitDate?: string | undefined;
+    legacyId?: string | undefined;
+}, {
+    id: string;
+    updatedAt?: string | undefined;
+    updatedBy?: string | undefined;
+    brandId?: string | undefined;
+    deletedAt?: string | null | undefined;
+    deletedBy?: string | null | undefined;
+    email?: string | undefined;
+    phone?: string | undefined;
+    lastName?: string | undefined;
+    firstName?: string | undefined;
+    locale?: string | undefined;
+    gdprConsent?: boolean | undefined;
+    gdprConsentDate?: string | undefined;
+    marketingOptIn?: boolean | undefined;
+    preferences?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    totalVisits?: number | undefined;
+    lastVisitDate?: string | undefined;
+    firstVisitDate?: string | undefined;
+    legacyId?: string | undefined;
+}>;
+/**
+ * Zod schema for merging contacts
+ */
+declare const mergeContactsSchema: z.ZodObject<{
+    primaryId: z.ZodString;
+    duplicateIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    primaryId: string;
+    duplicateIds: string[];
+}, {
+    primaryId: string;
+    duplicateIds: string[];
+}>;
+/**
+ * Validation error class for contact operations
+ */
+declare class ContactValidationError extends Error {
+    readonly issues: z.ZodIssue[];
+    constructor(message: string, issues?: z.ZodIssue[]);
+}
+/**
+ * Input type for creating a contact
+ */
+interface CreateContactInput extends CreateAuditFields {
+    brandId: string;
+    email: string;
+    phone?: string;
+    firstName: string;
+    lastName: string;
+    locale?: string;
+    gdprConsent: boolean;
+    gdprConsentDate?: string;
+    marketingOptIn?: boolean;
+    preferences?: Record<string, any>;
+    tags?: string[];
+    totalVisits?: number;
+    lastVisitDate?: string;
+    firstVisitDate?: string;
+    legacyId?: string;
+}
+/**
+ * Input type for updating a contact
+ */
+interface UpdateContactInput extends UpdateWithSoftDeleteFields {
+    id: string;
+    brandId?: string;
+    email?: string;
+    phone?: string;
+    firstName?: string;
+    lastName?: string;
+    locale?: string;
+    gdprConsent?: boolean;
+    gdprConsentDate?: string;
+    marketingOptIn?: boolean;
+    preferences?: Record<string, any>;
+    tags?: string[];
+    totalVisits?: number;
+    lastVisitDate?: string;
+    firstVisitDate?: string;
+    legacyId?: string;
+}
+/**
+ * Input type for merging contacts
+ */
+interface MergeContactsInput {
+    primaryId: string;
+    duplicateIds: string[];
+}
+/**
+ * Result type for merge operation
+ */
+interface MergeContactsResult {
+    success: boolean;
+    mergedContact?: Contact;
+    deletedIds?: string[];
+    error?: string;
+}
+/**
+ * Create a new contact with Zod validation
+ *
+ * @throws {ContactValidationError} if input validation fails
+ *
+ * @example
+ * ```typescript
+ * import { createContact } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contact = await createContact(client, {
+ *   brandId: 'brand-123',
+ *   email: 'guest@example.com',
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   gdprConsent: true,
+ *   gdprConsentDate: new Date().toISOString()
+ * });
+ * ```
+ */
+declare function createContact<TClient = any>(client: TClient, input: CreateContactInput): Promise<Contact | null>;
+/**
+ * Update an existing contact with Zod validation
+ *
+ * @throws {ContactValidationError} if input validation fails
+ *
+ * @example
+ * ```typescript
+ * import { updateContact } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contact = await updateContact(client, {
+ *   id: 'contact-123',
+ *   firstName: 'Jane',
+ *   marketingOptIn: true
+ * });
+ * ```
+ */
+declare function updateContact<TClient = any>(client: TClient, input: UpdateContactInput): Promise<Contact | null>;
+/**
+ * Soft delete a contact (sets deletedAt/deletedBy instead of removing)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteContact } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await softDeleteContact(client, 'contact-123', 'admin@example.com');
+ * ```
+ */
+declare function softDeleteContact<TClient = any>(client: TClient, id: string, deletedBy: string): Promise<boolean>;
+/**
+ * Restore a soft-deleted contact
+ * Checks retention period before allowing restoration
+ *
+ * @example
+ * ```typescript
+ * import { restoreContact } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await restoreContact(client, 'contact-123');
+ * // Or with custom retention days:
+ * await restoreContact(client, 'contact-123', 60);
+ * ```
+ */
+declare function restoreContact<TClient = any>(client: TClient, id: string, retentionDays?: number): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Hard delete a contact (permanently removes from database)
+ * Use with caution - prefer softDeleteContact for recoverable deletion
+ *
+ * @example
+ * ```typescript
+ * import { deleteContact } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteContact(client, 'contact-123');
+ * ```
+ */
+declare function deleteContact<TClient = any>(client: TClient, id: string): Promise<boolean>;
+/**
+ * Merge duplicate contacts into a primary contact
+ *
+ * This function:
+ * 1. Validates all contact IDs exist
+ * 2. Aggregates data from duplicates into the primary contact
+ * 3. Soft deletes the duplicate contacts
+ * 4. Returns the updated primary contact
+ *
+ * Merge strategy:
+ * - totalVisits: Sum of all contacts
+ * - firstVisitDate: Earliest date across all contacts
+ * - lastVisitDate: Latest date across all contacts
+ * - tags: Merged unique tags from all contacts
+ * - preferences: Primary contact preferences take precedence
+ * - Other fields: Primary contact values are preserved
+ *
+ * @throws {ContactValidationError} if input validation fails
+ *
+ * @example
+ * ```typescript
+ * import { mergeContacts } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const result = await mergeContacts(client, {
+ *   primaryId: 'contact-primary',
+ *   duplicateIds: ['contact-dup-1', 'contact-dup-2']
+ * }, 'admin@example.com');
+ * ```
+ */
+declare function mergeContacts<TClient = any>(client: TClient, input: MergeContactsInput, mergedBy: string): Promise<MergeContactsResult>;
+
+export { ContactValidationError, type CreateAccountInput, CreateAuditFields, type CreateBrandInput, type CreateContactInput, type CreateUserInput, type MergeContactsInput, type MergeContactsResult, type UpdateAccountInput, type UpdateBrandInput, type UpdateContactInput, type UpdateSystemSettingsInput, type UpdateUserInput, UpdateWithSoftDeleteFields, createAccount, createBrand, createContact, createContactSchema, createUser, deleteAccount, deleteBrand, deleteContact, deleteUser, initializeSystemSettings, mergeContacts, mergeContactsSchema, restoreAccount, restoreBrand, restoreContact, restoreUser, softDeleteAccount, softDeleteBrand, softDeleteContact, softDeleteUser, updateAccount, updateBrand, updateContact, updateContactSchema, updateSystemSettings, updateUser };

package/dist/mutations/index.js

@@ -702,30 +702,316 @@ async function updateReservationStatus(client, id, newStatus) {
     throw error;
   }
 }
+
+// src/mutations/contacts.ts
+import { z } from "zod";
+
+// 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;
+  }
+}
+
+// src/mutations/contacts.ts
+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;
+  }
+}
 export {
+  ContactValidationError,
   ReservationValidationError,
   createAccount,
   createBrand,
+  createContact,
+  createContactSchema,
   createProductInstance,
   createReservation,
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteContact,
   deleteProductInstance,
   deleteReservation,
   deleteUser,
   initializeSystemSettings,
+  mergeContacts,
+  mergeContactsSchema,
   restoreAccount,
   restoreBrand,
+  restoreContact,
   restoreReservation,
   restoreUser,
   softDeleteAccount,
   softDeleteBrand,
+  softDeleteContact,
   softDeleteReservation,
   softDeleteUser,
   toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateContact,
+  updateContactSchema,
   updateProductInstance,
   updateReservation,
   updateReservationStatus,