@htlkg/data 0.0.20 → 0.0.22

package/dist/hooks/index.d.ts

@@ -1,7 +1,7 @@
 import { Ref, ComputedRef } from 'vue';
-import { Brand, Account, User, Product, ProductInstance } from '@htlkg/core/types';
-import { C as CreateProductInstanceInput, U as UpdateProductInstanceInput } from '../productInstances-BpQv1oLS.js';
+import { Brand, User, Account, Product, ProductInstance, Contact } from '@htlkg/core/types';
 import { R as Reservation } from '../reservations-C0FNm__0.js';
+import { C as CreateProductInstanceInput, U as UpdateProductInstanceInput } from '../productInstances-BpQv1oLS.js';
 import '../common-DSxswsZ3.js';
 
 /**
@@ -107,6 +107,162 @@ declare function createDataHook<T, TOptions extends BaseHookOptions = BaseHookOp
  */
 type InferHookReturn<THook extends (...args: any[]) => any> = ReturnType<THook>;
 
+/**
+ * Paginated Data Hook Factory
+ *
+ * Creates reusable Vue composables for fetching paginated data from GraphQL models.
+ * Supports cursor-based pagination (nextToken) for efficient handling of large datasets.
+ *
+ * Key features:
+ * - Server-side pagination with nextToken
+ * - loadMore() for infinite scroll/pagination
+ * - hasMore indicator
+ * - Independent pagination state per hook instance
+ * - Built-in support for active/deleted filtering
+ */
+
+/**
+ * Filter for active items (not deleted)
+ * Uses OR condition because deletedAt can be:
+ * - Missing (attributeExists: false)
+ * - Explicitly null (eq: null)
+ */
+declare const ACTIVE_FILTER: {
+    or: ({
+        deletedAt: {
+            attributeExists: boolean;
+            eq?: undefined;
+        };
+    } | {
+        deletedAt: {
+            eq: null;
+            attributeExists?: undefined;
+        };
+    })[];
+};
+/**
+ * Filter for deleted items
+ * Uses gt: "" to match only actual timestamp strings (not null or missing)
+ */
+declare const DELETED_FILTER: {
+    deletedAt: {
+        gt: string;
+    };
+};
+/**
+ * Configuration options for creating a paginated data hook
+ */
+interface CreatePaginatedDataHookOptions<T, TOptions extends PaginatedHookOptions = PaginatedHookOptions> {
+    /** The GraphQL model name (e.g., 'Account', 'User', 'Brand') */
+    model: string;
+    /** Default page size */
+    defaultPageSize?: number;
+    /** Selection set for the query (fields to fetch) */
+    selectionSet?: string[];
+    /** Transform function to apply to fetched data */
+    transform?: (item: any) => T;
+    /** Build filter from hook options */
+    buildFilter?: (options: TOptions) => any;
+    /** Plural name for the data property (e.g., 'accounts', 'users') */
+    dataPropertyName?: string;
+    /** Base filter to always apply (e.g., for active/deleted variants) */
+    baseFilter?: any;
+}
+/**
+ * Base options available to paginated hooks
+ */
+interface PaginatedHookOptions {
+    /** Additional filter criteria (merged with baseFilter) */
+    filter?: any;
+    /** Page size (default: 25) */
+    pageSize?: number;
+    /** Auto-fetch on mount (default: true) */
+    autoFetch?: boolean;
+}
+/**
+ * Pagination state
+ */
+interface PaginationState {
+    /** Current nextToken for fetching next page */
+    nextToken: string | null;
+    /** Whether there are more items to load */
+    hasMore: boolean;
+    /** Total items loaded so far */
+    loadedCount: number;
+}
+/**
+ * Return type for paginated data hooks
+ */
+interface PaginatedDataHookReturn<T> {
+    /** Reactive array of data (accumulated across pages) */
+    data: Ref<T[]>;
+    /** Loading state (true during any fetch) */
+    loading: Ref<boolean>;
+    /** Loading state for initial fetch */
+    initialLoading: Ref<boolean>;
+    /** Loading state for loadMore */
+    loadingMore: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Pagination state */
+    pagination: Ref<PaginationState>;
+    /** Whether there are more items to load */
+    hasMore: ComputedRef<boolean>;
+    /** Load next page of data */
+    loadMore: () => Promise<void>;
+    /** Refetch data (resets to first page) */
+    refetch: () => Promise<void>;
+    /** Reset data and pagination state */
+    reset: () => void;
+    /** Update search filter and refetch from server (searches ALL data) */
+    setSearchFilter: (filter: any) => Promise<void>;
+    /** Current search filter */
+    searchFilter: Ref<any>;
+}
+/**
+ * Creates a reusable paginated data hook for a specific model
+ *
+ * @example
+ * ```typescript
+ * // Create a hook for active brands
+ * export const useActiveBrands = createPaginatedDataHook<Brand>({
+ *   model: 'Brand',
+ *   dataPropertyName: 'brands',
+ *   baseFilter: ACTIVE_FILTER,
+ *   selectionSet: ['id', 'name', 'status', 'accountId', 'account.name'],
+ * });
+ *
+ * // Usage in component
+ * const { brands, loading, hasMore, loadMore, refetch } = useActiveBrands({
+ *   pageSize: 25,
+ * });
+ * ```
+ *
+ * @example With custom filter builder
+ * ```typescript
+ * interface UseBrandsOptions extends PaginatedHookOptions {
+ *   accountId?: string;
+ * }
+ *
+ * export const useActiveBrands = createPaginatedDataHook<Brand, UseBrandsOptions>({
+ *   model: 'Brand',
+ *   dataPropertyName: 'brands',
+ *   baseFilter: ACTIVE_FILTER,
+ *   buildFilter: (options) => {
+ *     if (options.accountId) {
+ *       return { accountId: { eq: options.accountId } };
+ *     }
+ *     return undefined;
+ *   },
+ * });
+ * ```
+ */
+declare function createPaginatedDataHook<T, TOptions extends PaginatedHookOptions = PaginatedHookOptions>(config: CreatePaginatedDataHookOptions<T, TOptions>): (options?: TOptions) => PaginatedDataHookReturn<T> & Record<string, any>;
+/**
+ * Type helper to extract the return type of a created paginated hook
+ */
+type InferPaginatedHookReturn<THook extends (...args: any[]) => any> = ReturnType<THook>;
+
 /**
  * useBrands Hook
  *
@@ -160,49 +316,90 @@ interface UseBrandsReturn {
 declare function useBrands(options?: UseBrandsOptions): UseBrandsReturn;
 
 /**
- * useAccounts Hook
+ * Paginated Brands Hooks
  *
- * Vue composable for fetching and managing account data with reactive state.
- * Provides loading states, error handling, and refetch capabilities.
+ * Vue composables for fetching brands with server-side pagination.
+ * Provides separate hooks for active and deleted brands to enable
+ * efficient tab-based filtering in large datasets.
  */
 
-interface UseAccountsOptions extends BaseHookOptions {
-    /** Filter criteria for accounts */
-    filter?: any;
-    /** Limit number of results */
-    limit?: number;
-    /** Auto-fetch on mount (default: true) */
-    autoFetch?: boolean;
+/** Extended Brand type with computed fields */
+type BrandWithCounts = Brand & {
+    accountName?: string;
+    enabledProductCount?: number;
+    totalProductCount?: number;
+    deletedAt?: string;
+    deletedBy?: string;
+};
+interface UsePaginatedBrandsOptions extends PaginatedHookOptions {
+    /** Filter by account ID */
+    accountId?: string;
 }
-interface UseAccountsReturn {
-    /** Reactive array of accounts */
-    accounts: Ref<Account[]>;
-    /** Loading state */
+interface UsePaginatedBrandsReturn {
+    /** Reactive array of brands */
+    brands: Ref<BrandWithCounts[]>;
+    /** Loading state (true during any fetch) */
     loading: Ref<boolean>;
+    /** Loading state for initial fetch */
+    initialLoading: Ref<boolean>;
+    /** Loading state for loadMore */
+    loadingMore: Ref<boolean>;
     /** Error state */
     error: Ref<Error | null>;
-    /** Refetch accounts */
+    /** Pagination state */
+    pagination: Ref<PaginationState>;
+    /** Whether there are more items to load */
+    hasMore: ComputedRef<boolean>;
+    /** Load next page of data */
+    loadMore: () => Promise<void>;
+    /** Refetch data (resets to first page) */
     refetch: () => Promise<void>;
+    /** Reset data and pagination state */
+    reset: () => void;
+    /** Update search filter and refetch from server (searches ALL data) */
+    setSearchFilter: (filter: any) => Promise<void>;
+    /** Current search filter */
+    searchFilter: Ref<any>;
 }
 /**
- * Composable for fetching and managing accounts
+ * Composable for fetching active (non-deleted) brands with pagination
  *
  * @example
  * ```typescript
- * import { useAccounts } from '@htlkg/data/hooks';
+ * import { useActiveBrands } from '@htlkg/data/hooks';
  *
- * const { accounts, loading, error, refetch } = useAccounts();
+ * const { brands, loading, hasMore, loadMore, refetch } = useActiveBrands({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
  * ```
  *
- * @example With filters
+ * @example With account filter
  * ```typescript
- * const { accounts, loading } = useAccounts({
- *   filter: { status: { eq: 'active' } },
- *   limit: 50
+ * const { brands, loading } = useActiveBrands({
+ *   accountId: 'account-123',
+ *   pageSize: 50
  * });
  * ```
  */
-declare function useAccounts(options?: UseAccountsOptions): UseAccountsReturn;
+declare function useActiveBrands(options?: UsePaginatedBrandsOptions): UsePaginatedBrandsReturn;
+/**
+ * Composable for fetching deleted brands with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedBrands } from '@htlkg/data/hooks';
+ *
+ * const { brands, loading, hasMore, loadMore, refetch } = useDeletedBrands({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+declare function useDeletedBrands(options?: UsePaginatedBrandsOptions): UsePaginatedBrandsReturn;
 
 /**
  * useUsers Hook
@@ -255,10 +452,390 @@ interface UseUsersReturn {
 declare function useUsers(options?: UseUsersOptions): UseUsersReturn;
 
 /**
- * useProducts Hook
+ * Paginated Users Hooks
+ *
+ * Vue composables for fetching users with server-side pagination.
+ * Provides separate hooks for active and deleted users to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+/** Extended User type with computed fields */
+type UserWithRelations = User & {
+    accountName?: string;
+    brandNames?: string[];
+    deletedAt?: string;
+    deletedBy?: string;
+};
+interface UsePaginatedUsersOptions extends PaginatedHookOptions {
+    /** Filter by brand ID */
+    brandId?: string;
+    /** Filter by account ID */
+    accountId?: string;
+}
+interface UsePaginatedUsersReturn {
+    /** Reactive array of users */
+    users: Ref<UserWithRelations[]>;
+    /** Loading state (true during any fetch) */
+    loading: Ref<boolean>;
+    /** Loading state for initial fetch */
+    initialLoading: Ref<boolean>;
+    /** Loading state for loadMore */
+    loadingMore: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Pagination state */
+    pagination: Ref<PaginationState>;
+    /** Whether there are more items to load */
+    hasMore: ComputedRef<boolean>;
+    /** Load next page of data */
+    loadMore: () => Promise<void>;
+    /** Refetch data (resets to first page) */
+    refetch: () => Promise<void>;
+    /** Reset data and pagination state */
+    reset: () => void;
+    /** Update search filter and refetch from server (searches ALL data) */
+    setSearchFilter: (filter: any) => Promise<void>;
+    /** Current search filter */
+    searchFilter: Ref<any>;
+}
+/**
+ * Composable for fetching active (non-deleted) users with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveUsers } from '@htlkg/data/hooks';
+ *
+ * const { users, loading, hasMore, loadMore, refetch } = useActiveUsers({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { users, loading } = useActiveUsers({
+ *   accountId: 'account-123',
+ *   brandId: 'brand-456',
+ *   pageSize: 50
+ * });
+ * ```
+ */
+declare function useActiveUsers(options?: UsePaginatedUsersOptions): UsePaginatedUsersReturn;
+/**
+ * Composable for fetching deleted users with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedUsers } from '@htlkg/data/hooks';
+ *
+ * const { users, loading, hasMore, loadMore, refetch } = useDeletedUsers({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+declare function useDeletedUsers(options?: UsePaginatedUsersOptions): UsePaginatedUsersReturn;
+
+/**
+ * useAccounts Hook
  *
- * Vue composable for fetching and managing product data with reactive state.
+ * Vue composable for fetching and managing account data with reactive state.
  * Provides loading states, error handling, and refetch capabilities.
+ * Includes brands relationship data for displaying brand info without separate queries.
+ */
+
+interface UseAccountsOptions extends BaseHookOptions {
+    /** Filter criteria for accounts */
+    filter?: any;
+    /** Limit number of results */
+    limit?: number;
+    /** Auto-fetch on mount (default: true) */
+    autoFetch?: boolean;
+}
+/** Brand info included with account */
+interface AccountBrand {
+    id: string;
+    name: string;
+    status?: string;
+}
+/** Extended account type with brands relationship */
+type AccountWithBrands = Account & {
+    brands: AccountBrand[];
+    brandCount: number;
+    deletedAt?: string;
+    deletedBy?: string;
+};
+interface UseAccountsReturn {
+    /** Reactive array of accounts with brands */
+    accounts: Ref<AccountWithBrands[]>;
+    /** Loading state */
+    loading: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Refetch accounts */
+    refetch: () => Promise<void>;
+}
+/**
+ * Composable for fetching and managing accounts
+ *
+ * @example
+ * ```typescript
+ * import { useAccounts } from '@htlkg/data/hooks';
+ *
+ * const { accounts, loading, error, refetch } = useAccounts();
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { accounts, loading } = useAccounts({
+ *   filter: { status: { eq: 'active' } },
+ *   limit: 50
+ * });
+ * ```
+ */
+declare function useAccounts(options?: UseAccountsOptions): UseAccountsReturn;
+
+/**
+ * Paginated Accounts Hooks
+ *
+ * Vue composables for fetching accounts with server-side pagination.
+ * Provides separate hooks for active and deleted accounts to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+interface UsePaginatedAccountsOptions extends PaginatedHookOptions {
+}
+interface UsePaginatedAccountsReturn {
+    /** Reactive array of accounts with brands */
+    accounts: Ref<AccountWithBrands[]>;
+    /** Loading state (true during any fetch) */
+    loading: Ref<boolean>;
+    /** Loading state for initial fetch */
+    initialLoading: Ref<boolean>;
+    /** Loading state for loadMore */
+    loadingMore: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Pagination state */
+    pagination: Ref<PaginationState>;
+    /** Whether there are more items to load */
+    hasMore: ComputedRef<boolean>;
+    /** Load next page of data */
+    loadMore: () => Promise<void>;
+    /** Refetch data (resets to first page) */
+    refetch: () => Promise<void>;
+    /** Reset data and pagination state */
+    reset: () => void;
+    /** Update search filter and refetch from server (searches ALL data) */
+    setSearchFilter: (filter: any) => Promise<void>;
+    /** Current search filter */
+    searchFilter: Ref<any>;
+}
+/**
+ * Composable for fetching active (non-deleted) accounts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveAccounts } from '@htlkg/data/hooks';
+ *
+ * const { accounts, loading, hasMore, loadMore, refetch } = useActiveAccounts({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ */
+declare function useActiveAccounts(options?: UsePaginatedAccountsOptions): UsePaginatedAccountsReturn;
+/**
+ * Composable for fetching deleted accounts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedAccounts } from '@htlkg/data/hooks';
+ *
+ * const { accounts, loading, hasMore, loadMore, refetch } = useDeletedAccounts({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+declare function useDeletedAccounts(options?: UsePaginatedAccountsOptions): UsePaginatedAccountsReturn;
+
+/**
+ * useReservations Hook
+ *
+ * Vue composable for fetching and managing reservation data with reactive state.
+ * Provides loading states, error handling, pagination, and refetch capabilities.
+ */
+
+interface UseReservationsOptions extends BaseHookOptions {
+    /** Filter by brand ID */
+    brandId?: string;
+    /** Filter by start date (check-in date >= startDate) */
+    startDate?: string;
+    /** Filter by end date (check-in date <= endDate) */
+    endDate?: string;
+    /** Filter by reservation status */
+    status?: Reservation["status"];
+    /** Filter by contact/visit ID */
+    contactId?: string;
+    /** Pagination token for fetching next page */
+    nextToken?: string;
+}
+/** Extended reservation type with related data */
+type ReservationWithRelations = Reservation & {
+    brandName: string;
+    guestName: string;
+    guestEmail: string;
+    guestPhone: string;
+};
+interface UseReservationsReturn {
+    /** Reactive array of reservations with brand and guest info */
+    reservations: Ref<ReservationWithRelations[]>;
+    /** Computed array of confirmed reservations */
+    confirmedReservations: ComputedRef<ReservationWithRelations[]>;
+    /** Computed array of active reservations (confirmed or checked_in) */
+    activeReservations: ComputedRef<ReservationWithRelations[]>;
+    /** Loading state */
+    loading: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Refetch reservations */
+    refetch: () => Promise<void>;
+}
+/**
+ * Composable for fetching and managing reservations
+ *
+ * @example
+ * ```typescript
+ * import { useReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, error, refetch } = useReservations({
+ *   brandId: 'brand-123',
+ *   startDate: '2026-01-01',
+ *   endDate: '2026-01-31',
+ *   status: 'confirmed'
+ * });
+ * ```
+ *
+ * @example With contact filter
+ * ```typescript
+ * const { reservations, loading } = useReservations({
+ *   contactId: 'contact-123',
+ *   limit: 50
+ * });
+ * ```
+ *
+ * @example With computed properties
+ * ```typescript
+ * const { reservations, activeReservations, confirmedReservations } = useReservations({
+ *   brandId: 'brand-123'
+ * });
+ *
+ * // activeReservations includes confirmed + checked_in
+ * // confirmedReservations includes only confirmed
+ * ```
+ */
+declare function useReservations(options?: UseReservationsOptions): UseReservationsReturn;
+
+/**
+ * Paginated Reservations Hooks
+ *
+ * Vue composables for fetching reservations with server-side pagination.
+ * Provides separate hooks for active and deleted reservations to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+interface UsePaginatedReservationsOptions extends PaginatedHookOptions {
+    /** Filter by brand ID */
+    brandId?: string;
+    /** Filter by start date (check-in date >= startDate) */
+    startDate?: string;
+    /** Filter by end date (check-in date <= endDate) */
+    endDate?: string;
+    /** Filter by reservation status */
+    status?: Reservation["status"];
+    /** Filter by contact/visit ID */
+    contactId?: string;
+}
+interface UsePaginatedReservationsReturn {
+    /** Reactive array of reservations with brand and guest info */
+    reservations: Ref<ReservationWithRelations[]>;
+    /** Loading state (true during any fetch) */
+    loading: Ref<boolean>;
+    /** Loading state for initial fetch */
+    initialLoading: Ref<boolean>;
+    /** Loading state for loadMore */
+    loadingMore: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Pagination state */
+    pagination: Ref<PaginationState>;
+    /** Whether there are more items to load */
+    hasMore: ComputedRef<boolean>;
+    /** Load next page of data */
+    loadMore: () => Promise<void>;
+    /** Refetch data (resets to first page) */
+    refetch: () => Promise<void>;
+    /** Reset data and pagination state */
+    reset: () => void;
+    /** Update search filter and refetch from server (searches ALL data) */
+    setSearchFilter: (filter: any) => Promise<void>;
+    /** Current search filter */
+    searchFilter: Ref<any>;
+}
+/**
+ * Composable for fetching active (non-deleted) reservations with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, hasMore, loadMore, refetch } = useActiveReservations({
+ *   pageSize: 25,
+ *   brandId: 'brand-123',
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ *
+ * @example With date filters
+ * ```typescript
+ * const { reservations, loading } = useActiveReservations({
+ *   brandId: 'brand-123',
+ *   startDate: '2026-01-01',
+ *   endDate: '2026-01-31',
+ *   status: 'confirmed'
+ * });
+ * ```
+ */
+declare function useActiveReservations(options?: UsePaginatedReservationsOptions): UsePaginatedReservationsReturn;
+/**
+ * Composable for fetching deleted reservations with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, hasMore, loadMore, refetch } = useDeletedReservations({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+declare function useDeletedReservations(options?: UsePaginatedReservationsOptions): UsePaginatedReservationsReturn;
+
+/**
+ * Product Hooks
+ *
+ * Vue composables for fetching and managing product data with reactive state.
  */
 
 interface UseProductsOptions extends BaseHookOptions {
@@ -288,7 +865,7 @@ interface UseProductsReturn {
  *
  * @example
  * ```typescript
- * import { useProducts } from '@htlkg/data/hooks';
+ * import { useProducts } from '@htlkg/data/hooks/products';
  *
  * const { products, loading, error, refetch } = useProducts();
  * ```
@@ -304,9 +881,9 @@ interface UseProductsReturn {
 declare function useProducts(options?: UseProductsOptions): UseProductsReturn;
 
 /**
- * useProductInstances Hook
+ * ProductInstance Hooks
  *
- * Vue composable for fetching and managing product instance data with reactive state.
+ * Vue composables for fetching and managing product instance data with reactive state.
  * Provides loading states, error handling, refetch capabilities, and CRUD operations.
  */
 
@@ -351,7 +928,7 @@ interface UseProductInstancesReturn {
  *
  * @example
  * ```typescript
- * import { useProductInstances } from '@htlkg/data/hooks';
+ * import { useProductInstances } from '@htlkg/data/hooks/productInstances';
  *
  * const { instances, loading, error, refetch } = useProductInstances();
  * ```
@@ -376,73 +953,89 @@ interface UseProductInstancesReturn {
 declare function useProductInstances(options?: UseProductInstancesOptions): UseProductInstancesReturn;
 
 /**
- * useReservations Hook
+ * useContacts Hook
  *
- * Vue composable for fetching and managing reservation data with reactive state.
- * Provides loading states, error handling, pagination, and refetch capabilities.
+ * Vue composable for fetching and managing contact data with reactive state.
+ * Provides loading states, error handling, search, pagination, and refetch capabilities.
  */
 
-interface UseReservationsOptions extends BaseHookOptions {
+interface UseContactsOptions extends BaseHookOptions {
     /** Filter by brand ID */
     brandId?: string;
-    /** Filter by start date (check-in date >= startDate) */
-    startDate?: string;
-    /** Filter by end date (check-in date <= endDate) */
-    endDate?: string;
-    /** Filter by reservation status */
-    status?: Reservation["status"];
-    /** Filter by contact/visit ID */
-    contactId?: string;
+    /** Search query (searches email, firstName, lastName) */
+    search?: string;
+    /** Filter by GDPR consent */
+    gdprConsent?: boolean;
+    /** Filter by marketing opt-in */
+    marketingOptIn?: boolean;
+    /** Filter by tags (contact must have at least one of these tags) */
+    tags?: string[];
     /** Pagination token for fetching next page */
     nextToken?: string;
 }
-interface UseReservationsReturn {
-    /** Reactive array of reservations */
-    reservations: Ref<Reservation[]>;
-    /** Computed array of confirmed reservations */
-    confirmedReservations: ComputedRef<Reservation[]>;
-    /** Computed array of active reservations (confirmed or checked_in) */
-    activeReservations: ComputedRef<Reservation[]>;
+interface UseContactsReturn {
+    /** Reactive array of contacts */
+    contacts: Ref<Contact[]>;
+    /** Computed array of contacts with GDPR consent */
+    consentedContacts: ComputedRef<Contact[]>;
+    /** Computed array of contacts opted-in for marketing */
+    marketingContacts: ComputedRef<Contact[]>;
     /** Loading state */
     loading: Ref<boolean>;
     /** Error state */
     error: Ref<Error | null>;
-    /** Refetch reservations */
+    /** Refetch contacts */
     refetch: () => Promise<void>;
 }
 /**
- * Composable for fetching and managing reservations
+ * Composable for fetching and managing contacts
  *
  * @example
  * ```typescript
- * import { useReservations } from '@htlkg/data/hooks';
+ * import { useContacts } from '@htlkg/data/hooks';
  *
- * const { reservations, loading, error, refetch } = useReservations({
+ * const { contacts, loading, error, refetch } = useContacts({
  *   brandId: 'brand-123',
- *   startDate: '2026-01-01',
- *   endDate: '2026-01-31',
- *   status: 'confirmed'
+ *   limit: 25
  * });
  * ```
  *
- * @example With contact filter
+ * @example With search
  * ```typescript
- * const { reservations, loading } = useReservations({
- *   contactId: 'contact-123',
- *   limit: 50
+ * const { contacts, loading } = useContacts({
+ *   brandId: 'brand-123',
+ *   search: 'john',
+ *   limit: 25
+ * });
+ * ```
+ *
+ * @example With GDPR and marketing filters
+ * ```typescript
+ * const { contacts, marketingContacts } = useContacts({
+ *   brandId: 'brand-123',
+ *   gdprConsent: true,
+ *   marketingOptIn: true
  * });
  * ```
  *
  * @example With computed properties
  * ```typescript
- * const { reservations, activeReservations, confirmedReservations } = useReservations({
+ * const { contacts, consentedContacts, marketingContacts } = useContacts({
  *   brandId: 'brand-123'
  * });
  *
- * // activeReservations includes confirmed + checked_in
- * // confirmedReservations includes only confirmed
+ * // consentedContacts - contacts with GDPR consent
+ * // marketingContacts - contacts opted-in for marketing
+ * ```
+ *
+ * @example With tag filtering
+ * ```typescript
+ * const { contacts } = useContacts({
+ *   brandId: 'brand-123',
+ *   tags: ['vip', 'returning']
+ * });
  * ```
  */
-declare function useReservations(options?: UseReservationsOptions): UseReservationsReturn;
+declare function useContacts(options?: UseContactsOptions): UseContactsReturn;
 
-export { type BaseHookOptions, type CreateDataHookOptions, type DataHookReturn, type InferHookReturn, type UseAccountsOptions, type UseAccountsReturn, type UseBrandsOptions, type UseBrandsReturn, type UseProductInstancesOptions, type UseProductInstancesReturn, type UseProductsOptions, type UseProductsReturn, type UseReservationsOptions, type UseReservationsReturn, type UseUsersOptions, type UseUsersReturn, createDataHook, resetClientInstance, useAccounts, useBrands, useProductInstances, useProducts, useReservations, useUsers };
+export { ACTIVE_FILTER, type AccountWithBrands, type BaseHookOptions, type BrandWithCounts, type CreateDataHookOptions, type CreatePaginatedDataHookOptions, DELETED_FILTER, type DataHookReturn, type InferHookReturn, type InferPaginatedHookReturn, type AccountWithBrands as PaginatedAccountWithBrands, type PaginatedDataHookReturn, type PaginatedHookOptions, type PaginationState, type ReservationWithRelations, type UseAccountsOptions, type UseAccountsReturn, type UseBrandsOptions, type UseBrandsReturn, type UseContactsOptions, type UseContactsReturn, type UsePaginatedAccountsOptions, type UsePaginatedAccountsReturn, type UsePaginatedBrandsOptions, type UsePaginatedBrandsReturn, type UsePaginatedReservationsOptions, type UsePaginatedReservationsReturn, type UsePaginatedUsersOptions, type UsePaginatedUsersReturn, type UseProductInstancesOptions, type UseProductInstancesReturn, type UseProductsOptions, type UseProductsReturn, type UseReservationsOptions, type UseReservationsReturn, type UseUsersOptions, type UseUsersReturn, type UserWithRelations, createDataHook, createPaginatedDataHook, resetClientInstance, useAccounts, useActiveAccounts, useActiveBrands, useActiveReservations, useActiveUsers, useBrands, useContacts, useDeletedAccounts, useDeletedBrands, useDeletedReservations, useDeletedUsers, useProductInstances, useProducts, useReservations, useUsers };