@htlkg/data 0.0.21 → 0.0.23

package/dist/hooks/index.d.ts

@@ -1,7 +1,7 @@
 import { Ref, ComputedRef } from 'vue';
-import { Brand, Account, User, Product, ProductInstance, Contact } 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,125 +452,219 @@ interface UseUsersReturn {
 declare function useUsers(options?: UseUsersOptions): UseUsersReturn;
 
 /**
- * useProducts Hook
+ * Paginated Users Hooks
  *
- * Vue composable for fetching and managing product data with reactive state.
- * Provides loading states, error handling, and refetch capabilities.
+ * 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.
  */
 
-interface UseProductsOptions extends BaseHookOptions {
-    /** Filter criteria for products */
-    filter?: any;
-    /** Limit number of results */
-    limit?: number;
-    /** Auto-fetch on mount (default: true) */
-    autoFetch?: boolean;
-    /** Only active products */
-    activeOnly?: boolean;
+/** 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 UseProductsReturn {
-    /** Reactive array of products */
-    products: Ref<Product[]>;
-    /** Computed array of active products only */
-    activeProducts: ComputedRef<Product[]>;
-    /** Loading state */
+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>;
-    /** Refetch products */
+    /** 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 products
+ * Composable for fetching active (non-deleted) users with pagination
  *
  * @example
  * ```typescript
- * import { useProducts } from '@htlkg/data/hooks';
+ * import { useActiveUsers } from '@htlkg/data/hooks';
  *
- * const { products, loading, error, refetch } = useProducts();
+ * 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 { products, loading } = useProducts({
- *   activeOnly: true,
- *   limit: 50
+ * const { users, loading } = useActiveUsers({
+ *   accountId: 'account-123',
+ *   brandId: 'brand-456',
+ *   pageSize: 50
  * });
  * ```
  */
-declare function useProducts(options?: UseProductsOptions): UseProductsReturn;
+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;
 
 /**
- * useProductInstances Hook
+ * useAccounts Hook
  *
- * Vue composable for fetching and managing product instance data with reactive state.
- * Provides loading states, error handling, refetch capabilities, and CRUD operations.
+ * 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 UseProductInstancesOptions extends BaseHookOptions {
-    /** Filter criteria for product instances */
+interface UseAccountsOptions extends BaseHookOptions {
+    /** Filter criteria for accounts */
     filter?: any;
     /** Limit number of results */
     limit?: number;
     /** Auto-fetch on mount (default: true) */
     autoFetch?: boolean;
-    /** Filter by brand ID */
-    brandId?: string;
-    /** Filter by account ID */
-    accountId?: string;
-    /** Filter by product ID */
-    productId?: string;
-    /** Only enabled instances */
-    enabledOnly?: boolean;
 }
-interface UseProductInstancesReturn {
-    /** Reactive array of product instances */
-    instances: Ref<ProductInstance[]>;
-    /** Computed array of enabled instances only */
-    enabledInstances: ComputedRef<ProductInstance[]>;
+/** 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 product instances */
+    /** Refetch accounts */
     refetch: () => Promise<void>;
-    /** Create a new product instance */
-    createInstance: (input: CreateProductInstanceInput) => Promise<ProductInstance>;
-    /** Update an existing product instance */
-    updateInstance: (input: UpdateProductInstanceInput) => Promise<ProductInstance>;
-    /** Delete a product instance */
-    deleteInstance: (id: string) => Promise<boolean>;
-    /** Toggle the enabled status of a product instance */
-    toggleEnabled: (id: string, enabled: boolean) => Promise<ProductInstance>;
 }
 /**
- * Composable for fetching and managing product instances
+ * Composable for fetching and managing accounts
  *
  * @example
  * ```typescript
- * import { useProductInstances } from '@htlkg/data/hooks';
+ * import { useAccounts } from '@htlkg/data/hooks';
  *
- * const { instances, loading, error, refetch } = useProductInstances();
+ * const { accounts, loading, error, refetch } = useAccounts();
  * ```
  *
  * @example With filters
  * ```typescript
- * const { instances, enabledInstances, loading } = useProductInstances({
- *   brandId: 'brand-123',
- *   enabledOnly: true,
+ * const { accounts, loading } = useAccounts({
+ *   filter: { status: { eq: 'active' } },
  *   limit: 50
  * });
  * ```
+ */
+declare function useAccounts(options?: UseAccountsOptions): UseAccountsReturn;
+
+/**
+ * Paginated Accounts Hooks
  *
- * @example For a specific account
+ * 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
- * const { instances, loading } = useProductInstances({
- *   accountId: 'account-456',
- *   autoFetch: true
+ * 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 useProductInstances(options?: UseProductInstancesOptions): UseProductInstancesReturn;
+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
@@ -396,13 +687,20 @@ interface UseReservationsOptions extends BaseHookOptions {
     /** 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 */
-    reservations: Ref<Reservation[]>;
+    /** Reactive array of reservations with brand and guest info */
+    reservations: Ref<ReservationWithRelations[]>;
     /** Computed array of confirmed reservations */
-    confirmedReservations: ComputedRef<Reservation[]>;
+    confirmedReservations: ComputedRef<ReservationWithRelations[]>;
     /** Computed array of active reservations (confirmed or checked_in) */
-    activeReservations: ComputedRef<Reservation[]>;
+    activeReservations: ComputedRef<ReservationWithRelations[]>;
     /** Loading state */
     loading: Ref<boolean>;
     /** Error state */
@@ -445,6 +743,215 @@ interface UseReservationsReturn {
  */
 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 {
+    /** Filter criteria for products */
+    filter?: any;
+    /** Limit number of results */
+    limit?: number;
+    /** Auto-fetch on mount (default: true) */
+    autoFetch?: boolean;
+    /** Only active products */
+    activeOnly?: boolean;
+}
+interface UseProductsReturn {
+    /** Reactive array of products */
+    products: Ref<Product[]>;
+    /** Computed array of active products only */
+    activeProducts: ComputedRef<Product[]>;
+    /** Loading state */
+    loading: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Refetch products */
+    refetch: () => Promise<void>;
+}
+/**
+ * Composable for fetching and managing products
+ *
+ * @example
+ * ```typescript
+ * import { useProducts } from '@htlkg/data/hooks/products';
+ *
+ * const { products, loading, error, refetch } = useProducts();
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { products, loading } = useProducts({
+ *   activeOnly: true,
+ *   limit: 50
+ * });
+ * ```
+ */
+declare function useProducts(options?: UseProductsOptions): UseProductsReturn;
+
+/**
+ * ProductInstance Hooks
+ *
+ * Vue composables for fetching and managing product instance data with reactive state.
+ * Provides loading states, error handling, refetch capabilities, and CRUD operations.
+ */
+
+interface UseProductInstancesOptions extends BaseHookOptions {
+    /** Filter criteria for product instances */
+    filter?: any;
+    /** Limit number of results */
+    limit?: number;
+    /** Auto-fetch on mount (default: true) */
+    autoFetch?: boolean;
+    /** Filter by brand ID */
+    brandId?: string;
+    /** Filter by account ID */
+    accountId?: string;
+    /** Filter by product ID */
+    productId?: string;
+    /** Only enabled instances */
+    enabledOnly?: boolean;
+}
+interface UseProductInstancesReturn {
+    /** Reactive array of product instances */
+    instances: Ref<ProductInstance[]>;
+    /** Computed array of enabled instances only */
+    enabledInstances: ComputedRef<ProductInstance[]>;
+    /** Loading state */
+    loading: Ref<boolean>;
+    /** Error state */
+    error: Ref<Error | null>;
+    /** Refetch product instances */
+    refetch: () => Promise<void>;
+    /** Create a new product instance */
+    createInstance: (input: CreateProductInstanceInput) => Promise<ProductInstance>;
+    /** Update an existing product instance */
+    updateInstance: (input: UpdateProductInstanceInput) => Promise<ProductInstance>;
+    /** Delete a product instance */
+    deleteInstance: (id: string) => Promise<boolean>;
+    /** Toggle the enabled status of a product instance */
+    toggleEnabled: (id: string, enabled: boolean) => Promise<ProductInstance>;
+}
+/**
+ * Composable for fetching and managing product instances
+ *
+ * @example
+ * ```typescript
+ * import { useProductInstances } from '@htlkg/data/hooks/productInstances';
+ *
+ * const { instances, loading, error, refetch } = useProductInstances();
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { instances, enabledInstances, loading } = useProductInstances({
+ *   brandId: 'brand-123',
+ *   enabledOnly: true,
+ *   limit: 50
+ * });
+ * ```
+ *
+ * @example For a specific account
+ * ```typescript
+ * const { instances, loading } = useProductInstances({
+ *   accountId: 'account-456',
+ *   autoFetch: true
+ * });
+ * ```
+ */
+declare function useProductInstances(options?: UseProductInstancesOptions): UseProductInstancesReturn;
+
 /**
  * useContacts Hook
  *
@@ -531,4 +1038,105 @@ interface UseContactsReturn {
  */
 declare function useContacts(options?: UseContactsOptions): UseContactsReturn;
 
-export { type BaseHookOptions, type CreateDataHookOptions, type DataHookReturn, type InferHookReturn, type UseAccountsOptions, type UseAccountsReturn, type UseBrandsOptions, type UseBrandsReturn, type UseContactsOptions, type UseContactsReturn, type UseProductInstancesOptions, type UseProductInstancesReturn, type UseProductsOptions, type UseProductsReturn, type UseReservationsOptions, type UseReservationsReturn, type UseUsersOptions, type UseUsersReturn, createDataHook, resetClientInstance, useAccounts, useBrands, useContacts, useProductInstances, useProducts, useReservations, useUsers };
+/**
+ * Paginated Contacts Hooks
+ *
+ * Vue composables for fetching contacts with server-side pagination.
+ * Provides separate hooks for active and deleted contacts to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+/** Extended Contact type with computed fields */
+type ContactWithRelations = Contact & {
+    brandName?: string;
+    name?: string;
+    deletedAt?: string;
+    deletedBy?: string;
+};
+interface UsePaginatedContactsOptions extends PaginatedHookOptions {
+    /** Filter by brand ID */
+    brandId?: string;
+    /** Filter by account ID */
+    accountId?: 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[];
+}
+interface UsePaginatedContactsReturn {
+    /** Reactive array of contacts */
+    contacts: Ref<ContactWithRelations[]>;
+    /** 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) contacts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveContacts } from '@htlkg/data/hooks';
+ *
+ * const { contacts, loading, hasMore, loadMore, refetch, setSearchFilter } = useActiveContacts({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ *
+ * // Server-side search (searches ALL contacts in database)
+ * async function onSearch(filter: any) {
+ *   await setSearchFilter(filter);
+ * }
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { contacts, loading } = useActiveContacts({
+ *   brandId: 'brand-123',
+ *   gdprConsent: true,
+ *   pageSize: 50
+ * });
+ * ```
+ */
+declare function useActiveContacts(options?: UsePaginatedContactsOptions): UsePaginatedContactsReturn;
+/**
+ * Composable for fetching deleted contacts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedContacts } from '@htlkg/data/hooks';
+ *
+ * const { contacts, loading, hasMore, loadMore, refetch } = useDeletedContacts({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+declare function useDeletedContacts(options?: UsePaginatedContactsOptions): UsePaginatedContactsReturn;
+
+export { ACTIVE_FILTER, type AccountWithBrands, type BaseHookOptions, type BrandWithCounts, type ContactWithRelations, 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 UsePaginatedContactsOptions, type UsePaginatedContactsReturn, 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, useActiveContacts, useActiveReservations, useActiveUsers, useBrands, useContacts, useDeletedAccounts, useDeletedBrands, useDeletedContacts, useDeletedReservations, useDeletedUsers, useProductInstances, useProducts, useReservations, useUsers };