@growsober/sdk 1.0.5 → 1.0.8

package/dist/api/queries/venues.d.ts

@@ -0,0 +1,304 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { VenueResponse, VenueOwnerResponse, EventResponse, OfferResponse } from '../types';
+export declare const venueKeys: {
+    all: readonly ["venues"];
+    lists: () => readonly ["venues", "list"];
+    list: (filters?: VenueFilters) => readonly ["venues", "list", VenueFilters | undefined];
+    details: () => readonly ["venues", "detail"];
+    detail: (id: string) => readonly ["venues", "detail", string];
+    featured: () => readonly ["venues", "featured"];
+    nearby: (params?: NearbyVenueParams) => readonly ["venues", "nearby", NearbyVenueParams | undefined];
+    owners: (venueId: string) => readonly ["venues", "detail", string, "owners"];
+    events: (venueId: string) => readonly ["venues", "detail", string, "events"];
+    offers: (venueId: string) => readonly ["venues", "detail", string, "offers"];
+    rewards: (venueId: string) => readonly ["venues", "detail", string, "rewards"];
+};
+export interface VenueFilters {
+    page?: number;
+    limit?: number;
+    search?: string;
+    cityId?: string;
+    type?: string;
+    hasAfDrinks?: boolean;
+    isAfVenue?: boolean;
+    isFeatured?: boolean;
+    isFoundingPartner?: boolean;
+    lat?: number;
+    long?: number;
+    radius?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+export interface NearbyVenueParams {
+    lat: number;
+    long: number;
+    radius?: number;
+    limit?: number;
+}
+export interface PaginatedVenuesResponse {
+    venues: VenueResponse[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    };
+}
+/**
+ * Get paginated list of venues with optional filters
+ *
+ * @param filters - Query parameters for filtering and pagination
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenues({
+ *   page: 1,
+ *   limit: 20,
+ *   cityId: 'city-123',
+ *   hasAfDrinks: true,
+ * });
+ * ```
+ */
+export declare function useVenues(filters?: VenueFilters, options?: Omit<UseQueryOptions<PaginatedVenuesResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<PaginatedVenuesResponse, Error>;
+/**
+ * Get featured venues
+ *
+ * @param limit - Maximum number of venues to return
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFeaturedVenues(10);
+ * ```
+ */
+export declare function useFeaturedVenues(limit?: number, options?: Omit<UseQueryOptions<VenueResponse[]>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    appId: string;
+    name: string;
+    slug: string;
+    description?: Record<string, never>;
+    type: "COFFEE_SHOP" | "RESTAURANT" | "BAR" | "WELLNESS" | "VENUE" | "ACTIVITY" | "RETAIL" | "OTHER";
+    hasAfDrinks: boolean;
+    isAfVenue: boolean;
+    afHighlights: string[];
+    address?: Record<string, never>;
+    cityId?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    phone?: Record<string, never>;
+    email?: Record<string, never>;
+    website?: Record<string, never>;
+    instagram?: Record<string, never>;
+    profileImage?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    photos: string[];
+    openingHours?: Record<string, never>;
+    rating?: Record<string, never>;
+    reviewCount: number;
+    isActive: boolean;
+    isVerified: boolean;
+    isFeatured: boolean;
+    isFoundingPartner: boolean;
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;
+/**
+ * Get nearby venues based on location
+ *
+ * @param params - Location parameters (latitude, longitude, radius)
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useNearbyVenues({
+ *   lat: 51.5074,
+ *   long: -0.1278,
+ *   radius: 5, // 5km radius
+ *   limit: 20,
+ * });
+ * ```
+ */
+export declare function useNearbyVenues(params: NearbyVenueParams, options?: Omit<UseQueryOptions<VenueResponse[]>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    appId: string;
+    name: string;
+    slug: string;
+    description?: Record<string, never>;
+    type: "COFFEE_SHOP" | "RESTAURANT" | "BAR" | "WELLNESS" | "VENUE" | "ACTIVITY" | "RETAIL" | "OTHER";
+    hasAfDrinks: boolean;
+    isAfVenue: boolean;
+    afHighlights: string[];
+    address?: Record<string, never>;
+    cityId?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    phone?: Record<string, never>;
+    email?: Record<string, never>;
+    website?: Record<string, never>;
+    instagram?: Record<string, never>;
+    profileImage?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    photos: string[];
+    openingHours?: Record<string, never>;
+    rating?: Record<string, never>;
+    reviewCount: number;
+    isActive: boolean;
+    isVerified: boolean;
+    isFeatured: boolean;
+    isFoundingPartner: boolean;
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;
+/**
+ * Get a single venue by ID
+ *
+ * @param id - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenue('venue-123');
+ * ```
+ */
+export declare function useVenue(id: string, options?: Omit<UseQueryOptions<VenueResponse>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    appId: string;
+    name: string;
+    slug: string;
+    description?: Record<string, never>;
+    type: "COFFEE_SHOP" | "RESTAURANT" | "BAR" | "WELLNESS" | "VENUE" | "ACTIVITY" | "RETAIL" | "OTHER";
+    hasAfDrinks: boolean;
+    isAfVenue: boolean;
+    afHighlights: string[];
+    address?: Record<string, never>;
+    cityId?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    phone?: Record<string, never>;
+    email?: Record<string, never>;
+    website?: Record<string, never>;
+    instagram?: Record<string, never>;
+    profileImage?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    photos: string[];
+    openingHours?: Record<string, never>;
+    rating?: Record<string, never>;
+    reviewCount: number;
+    isActive: boolean;
+    isVerified: boolean;
+    isFeatured: boolean;
+    isFoundingPartner: boolean;
+    createdAt: string;
+    updatedAt: string;
+}, Error>;
+/**
+ * Get venue owners
+ *
+ * @param venueId - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueOwners('venue-123');
+ * ```
+ */
+export declare function useVenueOwners(venueId: string, options?: Omit<UseQueryOptions<VenueOwnerResponse[]>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    venueId: string;
+    userId: string;
+    role: "OWNER" | "MANAGER";
+    user?: import("@growsober/types/dist/generated").components["schemas"]["VenueOwnerUserDto"];
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;
+/**
+ * Get upcoming events at a venue
+ *
+ * @param venueId - Venue ID
+ * @param limit - Maximum number of events to return
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueEvents('venue-123', 20);
+ * ```
+ */
+export declare function useVenueEvents(venueId: string, limit?: number, options?: Omit<UseQueryOptions<EventResponse[]>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    title: string;
+    slug?: Record<string, never>;
+    description?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    startDate: string;
+    endDate?: Record<string, never>;
+    timezone?: Record<string, never>;
+    isRecurring: boolean;
+    recurrenceRule?: Record<string, never>;
+    locationName?: Record<string, never>;
+    locationAddress?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    cityId?: Record<string, never>;
+    isOnline: boolean;
+    onlineUrl?: Record<string, never>;
+    totalSpots: number;
+    availableSpots: number;
+    isFree: boolean;
+    price?: Record<string, never>;
+    currency: string;
+    hubId?: Record<string, never>;
+    venueId?: Record<string, never>;
+    creatorId?: Record<string, never>;
+    sponsorBrandId?: Record<string, never>;
+    gatheringType?: "FACILITATOR_LED" | "COMMUNITY" | "SOCIAL" | "ONLINE";
+    visibility: "PUBLIC" | "MEMBERS_ONLY" | "INVITE_ONLY";
+    requiresApproval: boolean;
+    allowWaitlist: boolean;
+    whatsappGroup?: Record<string, never>;
+    externalUrl?: Record<string, never>;
+    status: "DRAFT" | "PUBLISHED" | "CANCELLED" | "COMPLETED";
+    isFeatured: boolean;
+    isCancelled: boolean;
+    isAmbient: boolean;
+    ambientCategory?: Record<string, never>;
+    vibe?: "CHILL" | "ACTIVE" | "SOCIAL" | "CREATIVE" | "DEEP_TALK" | "ADVENTURE";
+    city?: import("@growsober/types/dist/generated").components["schemas"]["EventCityDto"];
+    venue?: import("@growsober/types/dist/generated").components["schemas"]["EventVenueDto"];
+    creator?: import("@growsober/types/dist/generated").components["schemas"]["EventCreatorDto"];
+    sponsorBrand?: import("@growsober/types/dist/generated").components["schemas"]["EventBrandDto"];
+    bookingCount: number;
+    checkinCount: number;
+    createdAt: string;
+    publishedAt?: Record<string, never>;
+}[], Error>;
+/**
+ * Get offers for a venue (from legacy Business model)
+ *
+ * @param venueId - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueOffers('venue-123');
+ * ```
+ */
+export declare function useVenueOffers(venueId: string, options?: Omit<UseQueryOptions<OfferResponse[]>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    businessId: string;
+    title: string;
+    description?: Record<string, never>;
+    discountType?: "PERCENTAGE" | "FIXED_AMOUNT" | "FREE_ITEM" | "BOGO";
+    discountValue?: Record<string, never>;
+    discountCode?: Record<string, never>;
+    validFrom: string;
+    validTo?: Record<string, never>;
+    terms?: Record<string, never>;
+    maxRedemptions?: Record<string, never>;
+    redemptionCount: number;
+    perUserLimit?: Record<string, never>;
+    premiumOnly: boolean;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}[], Error>;

package/dist/api/queries/venues.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.venueKeys = void 0;
+exports.useVenues = useVenues;
+exports.useFeaturedVenues = useFeaturedVenues;
+exports.useNearbyVenues = useNearbyVenues;
+exports.useVenue = useVenue;
+exports.useVenueOwners = useVenueOwners;
+exports.useVenueEvents = useVenueEvents;
+exports.useVenueOffers = useVenueOffers;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+// ============================================================================
+// QUERY KEY FACTORY
+// ============================================================================
+exports.venueKeys = {
+    all: ['venues'],
+    lists: () => [...exports.venueKeys.all, 'list'],
+    list: (filters) => [...exports.venueKeys.lists(), filters],
+    details: () => [...exports.venueKeys.all, 'detail'],
+    detail: (id) => [...exports.venueKeys.details(), id],
+    featured: () => [...exports.venueKeys.all, 'featured'],
+    nearby: (params) => [...exports.venueKeys.all, 'nearby', params],
+    owners: (venueId) => [...exports.venueKeys.detail(venueId), 'owners'],
+    events: (venueId) => [...exports.venueKeys.detail(venueId), 'events'],
+    offers: (venueId) => [...exports.venueKeys.detail(venueId), 'offers'],
+    rewards: (venueId) => [...exports.venueKeys.detail(venueId), 'rewards'],
+};
+// ============================================================================
+// QUERY HOOKS
+// ============================================================================
+/**
+ * Get paginated list of venues with optional filters
+ *
+ * @param filters - Query parameters for filtering and pagination
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenues({
+ *   page: 1,
+ *   limit: 20,
+ *   cityId: 'city-123',
+ *   hasAfDrinks: true,
+ * });
+ * ```
+ */
+function useVenues(filters, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.list(filters),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/venues', {
+                params: filters,
+            });
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get featured venues
+ *
+ * @param limit - Maximum number of venues to return
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFeaturedVenues(10);
+ * ```
+ */
+function useFeaturedVenues(limit, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.featured(),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/venues/featured', {
+                params: { limit },
+            });
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get nearby venues based on location
+ *
+ * @param params - Location parameters (latitude, longitude, radius)
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useNearbyVenues({
+ *   lat: 51.5074,
+ *   long: -0.1278,
+ *   radius: 5, // 5km radius
+ *   limit: 20,
+ * });
+ * ```
+ */
+function useNearbyVenues(params, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.nearby(params),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/venues/nearby', {
+                params,
+            });
+            return response.data;
+        },
+        enabled: !!params.lat && !!params.long,
+        ...options,
+    });
+}
+/**
+ * Get a single venue by ID
+ *
+ * @param id - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenue('venue-123');
+ * ```
+ */
+function useVenue(id, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.detail(id),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/venues/${id}`);
+            return response.data;
+        },
+        enabled: !!id,
+        ...options,
+    });
+}
+/**
+ * Get venue owners
+ *
+ * @param venueId - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueOwners('venue-123');
+ * ```
+ */
+function useVenueOwners(venueId, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.owners(venueId),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/venues/${venueId}/owners`);
+            return response.data;
+        },
+        enabled: !!venueId,
+        ...options,
+    });
+}
+/**
+ * Get upcoming events at a venue
+ *
+ * @param venueId - Venue ID
+ * @param limit - Maximum number of events to return
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueEvents('venue-123', 20);
+ * ```
+ */
+function useVenueEvents(venueId, limit, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.events(venueId),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/venues/${venueId}/events`, {
+                params: { limit },
+            });
+            return response.data?.data || response.data || [];
+        },
+        enabled: !!venueId,
+        ...options,
+    });
+}
+/**
+ * Get offers for a venue (from legacy Business model)
+ *
+ * @param venueId - Venue ID
+ * @param options - TanStack Query options
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useVenueOffers('venue-123');
+ * ```
+ */
+function useVenueOffers(venueId, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.venueKeys.offers(venueId),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            // Use businesses endpoint for offers (legacy)
+            const response = await client.get(`/api/v1/businesses/${venueId}/offers`);
+            return response.data;
+        },
+        enabled: !!venueId,
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"venues.js","sourceRoot":"","sources":["../../../src/api/queries/venues.ts"],"names":[],"mappings":"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","sourcesContent":["import { useQuery, UseQueryOptions } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport type { VenueResponse, VenueOwnerResponse, EventResponse, OfferResponse } from '../types';\n\n// ============================================================================\n// QUERY KEY FACTORY\n// ============================================================================\n\nexport const venueKeys = {\n  all: ['venues'] as const,\n  lists: () => [...venueKeys.all, 'list'] as const,\n  list: (filters?: VenueFilters) => [...venueKeys.lists(), filters] as const,\n  details: () => [...venueKeys.all, 'detail'] as const,\n  detail: (id: string) => [...venueKeys.details(), id] as const,\n  featured: () => [...venueKeys.all, 'featured'] as const,\n  nearby: (params?: NearbyVenueParams) => [...venueKeys.all, 'nearby', params] as const,\n  owners: (venueId: string) => [...venueKeys.detail(venueId), 'owners'] as const,\n  events: (venueId: string) => [...venueKeys.detail(venueId), 'events'] as const,\n  offers: (venueId: string) => [...venueKeys.detail(venueId), 'offers'] as const,\n  rewards: (venueId: string) => [...venueKeys.detail(venueId), 'rewards'] as const,\n};\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface VenueFilters {\n  page?: number;\n  limit?: number;\n  search?: string;\n  cityId?: string;\n  type?: string;\n  hasAfDrinks?: boolean;\n  isAfVenue?: boolean;\n  isFeatured?: boolean;\n  isFoundingPartner?: boolean;\n  lat?: number;\n  long?: number;\n  radius?: number;\n  sortBy?: string;\n  sortOrder?: 'asc' | 'desc';\n}\n\nexport interface NearbyVenueParams {\n  lat: number;\n  long: number;\n  radius?: number;\n  limit?: number;\n}\n\nexport interface PaginatedVenuesResponse {\n  venues: VenueResponse[];\n  meta: {\n    total: number;\n    page: number;\n    limit: number;\n    totalPages: number;\n  };\n}\n\n// ============================================================================\n// QUERY HOOKS\n// ============================================================================\n\n/**\n * Get paginated list of venues with optional filters\n *\n * @param filters - Query parameters for filtering and pagination\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useVenues({\n *   page: 1,\n *   limit: 20,\n *   cityId: 'city-123',\n *   hasAfDrinks: true,\n * });\n * ```\n */\nexport function useVenues(\n  filters?: VenueFilters,\n  options?: Omit<UseQueryOptions<PaginatedVenuesResponse>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.list(filters),\n    queryFn: async (): Promise<PaginatedVenuesResponse> => {\n      const client = getApiClient();\n      const response = await client.get('/api/v1/venues', {\n        params: filters,\n      });\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get featured venues\n *\n * @param limit - Maximum number of venues to return\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useFeaturedVenues(10);\n * ```\n */\nexport function useFeaturedVenues(\n  limit?: number,\n  options?: Omit<UseQueryOptions<VenueResponse[]>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.featured(),\n    queryFn: async (): Promise<VenueResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get('/api/v1/venues/featured', {\n        params: { limit },\n      });\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get nearby venues based on location\n *\n * @param params - Location parameters (latitude, longitude, radius)\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useNearbyVenues({\n *   lat: 51.5074,\n *   long: -0.1278,\n *   radius: 5, // 5km radius\n *   limit: 20,\n * });\n * ```\n */\nexport function useNearbyVenues(\n  params: NearbyVenueParams,\n  options?: Omit<UseQueryOptions<VenueResponse[]>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.nearby(params),\n    queryFn: async (): Promise<VenueResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get('/api/v1/venues/nearby', {\n        params,\n      });\n      return response.data;\n    },\n    enabled: !!params.lat && !!params.long,\n    ...options,\n  });\n}\n\n/**\n * Get a single venue by ID\n *\n * @param id - Venue ID\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useVenue('venue-123');\n * ```\n */\nexport function useVenue(\n  id: string,\n  options?: Omit<UseQueryOptions<VenueResponse>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.detail(id),\n    queryFn: async (): Promise<VenueResponse> => {\n      const client = getApiClient();\n      const response = await client.get(`/api/v1/venues/${id}`);\n      return response.data;\n    },\n    enabled: !!id,\n    ...options,\n  });\n}\n\n/**\n * Get venue owners\n *\n * @param venueId - Venue ID\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useVenueOwners('venue-123');\n * ```\n */\nexport function useVenueOwners(\n  venueId: string,\n  options?: Omit<UseQueryOptions<VenueOwnerResponse[]>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.owners(venueId),\n    queryFn: async (): Promise<VenueOwnerResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get(`/api/v1/venues/${venueId}/owners`);\n      return response.data;\n    },\n    enabled: !!venueId,\n    ...options,\n  });\n}\n\n/**\n * Get upcoming events at a venue\n *\n * @param venueId - Venue ID\n * @param limit - Maximum number of events to return\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useVenueEvents('venue-123', 20);\n * ```\n */\nexport function useVenueEvents(\n  venueId: string,\n  limit?: number,\n  options?: Omit<UseQueryOptions<EventResponse[]>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.events(venueId),\n    queryFn: async (): Promise<EventResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get(`/api/v1/venues/${venueId}/events`, {\n        params: { limit },\n      });\n      return response.data?.data || response.data || [];\n    },\n    enabled: !!venueId,\n    ...options,\n  });\n}\n\n/**\n * Get offers for a venue (from legacy Business model)\n *\n * @param venueId - Venue ID\n * @param options - TanStack Query options\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useVenueOffers('venue-123');\n * ```\n */\nexport function useVenueOffers(\n  venueId: string,\n  options?: Omit<UseQueryOptions<OfferResponse[]>, 'queryKey' | 'queryFn'>\n) {\n  return useQuery({\n    queryKey: venueKeys.offers(venueId),\n    queryFn: async (): Promise<OfferResponse[]> => {\n      const client = getApiClient();\n      // Use businesses endpoint for offers (legacy)\n      const response = await client.get(`/api/v1/businesses/${venueId}/offers`);\n      return response.data;\n    },\n    enabled: !!venueId,\n    ...options,\n  });\n}\n"]}