@adventurelabs/scout-core 1.2.5 → 1.3.1

package/dist/helpers/cache.js

@@ -225,8 +225,10 @@ export class ScoutCache {
         const result = await this.getHerdModules();
         const totalRequests = this.stats.hits + this.stats.misses;
         const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+        // Calculate size based on herd modules count (no longer including events/sessions/artifacts arrays)
+        const size = result.data?.length || 0;
         return {
-            size: result.data?.length || 0,
+            size,
             lastUpdated: result.data ? Date.now() - result.age : 0,
             isStale: result.isStale,
             hitRate: Math.round(hitRate * 100) / 100,

package/dist/helpers/pins.d.ts

@@ -5,7 +5,9 @@ import { SupabaseClient } from "@supabase/supabase-js";
 export declare function get_pins_for_herd(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPin[]>>;
 export declare function get_pin_by_id(client: SupabaseClient<Database>, pin_id: number): Promise<IWebResponseCompatible<IPin | null>>;
 export declare function create_pin(client: SupabaseClient<Database>, newPin: PinInsert): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function create_pin_with_coordinates(client: SupabaseClient<Database>, latitude: number, longitude: number, pinData: Omit<PinInsert, "location">): Promise<IWebResponseCompatible<IPin | null>>;
 export declare function update_pin(client: SupabaseClient<Database>, pin_id: number, updatedPin: Partial<PinInsert>): Promise<IWebResponseCompatible<IPin | null>>;
+export declare function update_pin_location(client: SupabaseClient<Database>, pin_id: number, latitude: number, longitude: number, updatedPin?: Partial<Omit<PinInsert, "location">>): Promise<IWebResponseCompatible<IPin | null>>;
 export declare function delete_pin(client: SupabaseClient<Database>, pin_id: number): Promise<IWebResponseCompatible<IPin | null>>;
 export declare function get_pins_by_created_by(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IPin[]>>;
 export declare function get_pins_by_color(client: SupabaseClient<Database>, herd_id: number, color: string): Promise<IWebResponseCompatible<IPin[]>>;

package/dist/helpers/pins.js

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
 export async function get_pins_for_herd(client, herd_id) {
-    // Call get_pins_for_herd with rpc
+    // Call get_pins_for_herd with rpc - returns pins_pretty_location with extracted coordinates
     const { data, error } = await client.rpc("get_pins_for_herd", {
         herd_id_caller: herd_id,
     });
@@ -24,13 +24,8 @@ export async function get_pin_by_id(client, pin_id) {
     if (!data) {
         return IWebResponse.error("Pin not found").to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinWithCoords = {
-        ...data,
-        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
-        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
-    };
-    return IWebResponse.success(pinWithCoords).to_compatible();
+    // Raw table data - no coordinate extraction (use get_pins_for_herd for coordinates)
+    return IWebResponse.success(data).to_compatible();
 }
 export async function create_pin(client, newPin) {
     const { data, error } = await client
@@ -44,13 +39,30 @@ export async function create_pin(client, newPin) {
     if (!data) {
         return IWebResponse.error("Failed to create pin").to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinWithCoords = {
-        ...data,
-        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
-        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
-    };
-    return IWebResponse.success(pinWithCoords).to_compatible();
+    // Raw table data - coordinates extracted by RPC function or realtime broadcasts
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_pin_with_coordinates(client, latitude, longitude, pinData) {
+    // Create pin with PostGIS Point from lat/lng coordinates
+    const { data, error } = await client
+        .from("pins")
+        .insert([
+        {
+            ...pinData,
+            // Use PostGIS ST_MakePoint to create geography from coordinates
+            // Note: PostGIS Point format is (longitude, latitude)
+            location: `SRID=4326;POINT(${longitude} ${latitude})`,
+        },
+    ])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create pin").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
 }
 export async function update_pin(client, pin_id, updatedPin) {
     // Remove fields that shouldn't be updated
@@ -70,13 +82,32 @@ export async function update_pin(client, pin_id, updatedPin) {
     if (!data) {
         return IWebResponse.error("Pin not found or update failed").to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinWithCoords = {
-        ...data,
-        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
-        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
+    // Raw table data - coordinates extracted by RPC function or realtime broadcasts
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_pin_location(client, pin_id, latitude, longitude, updatedPin) {
+    const updateData = {
+        ...updatedPin,
+        // Use PostGIS format to update location
+        location: `SRID=4326;POINT(${longitude} ${latitude})`,
     };
-    return IWebResponse.success(pinWithCoords).to_compatible();
+    // Remove fields that shouldn't be updated
+    delete updateData.id;
+    delete updateData.created_at;
+    delete updateData.created_by;
+    const { data, error } = await client
+        .from("pins")
+        .update(updateData)
+        .eq("id", pin_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Pin not found or update failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
 }
 export async function delete_pin(client, pin_id) {
     const { data, error } = await client
@@ -91,13 +122,8 @@ export async function delete_pin(client, pin_id) {
     if (!data) {
         return IWebResponse.error("Pin not found or deletion failed").to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinWithCoords = {
-        ...data,
-        latitude: data.latitude ? parseFloat(data.latitude.toString()) : 0,
-        longitude: data.longitude ? parseFloat(data.longitude.toString()) : 0,
-    };
-    return IWebResponse.success(pinWithCoords).to_compatible();
+    // Raw table data - coordinates extracted by realtime broadcasts
+    return IWebResponse.success(data).to_compatible();
 }
 export async function get_pins_by_created_by(client, user_id) {
     const { data, error } = await client
@@ -111,13 +137,8 @@ export async function get_pins_by_created_by(client, user_id) {
     if (!data) {
         return IWebResponse.error("No pins found for user").to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinsWithCoords = data.map((pin) => ({
-        ...pin,
-        latitude: pin.latitude ? parseFloat(pin.latitude.toString()) : 0,
-        longitude: pin.longitude ? parseFloat(pin.longitude.toString()) : 0,
-    }));
-    return IWebResponse.success(pinsWithCoords).to_compatible();
+    // Raw table data without extracted coordinates - use get_pins_for_herd for coordinates
+    return IWebResponse.success(data).to_compatible();
 }
 export async function get_pins_by_color(client, herd_id, color) {
     const { data, error } = await client
@@ -132,11 +153,6 @@ export async function get_pins_by_color(client, herd_id, color) {
     if (!data) {
         return IWebResponse.error(`No pins found with color: ${color}`).to_compatible();
     }
-    // Convert to pretty location format with coordinates
-    const pinsWithCoords = data.map((pin) => ({
-        ...pin,
-        latitude: pin.latitude ? parseFloat(pin.latitude.toString()) : 0,
-        longitude: pin.longitude ? parseFloat(pin.longitude.toString()) : 0,
-    }));
-    return IWebResponse.success(pinsWithCoords).to_compatible();
+    // Raw table data without extracted coordinates - use get_pins_for_herd for coordinates
+    return IWebResponse.success(data).to_compatible();
 }

package/dist/helpers/session_summaries.d.ts

@@ -0,0 +1,6 @@
+import { ISessionSummary } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_session_summaries_by_herd(herd_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_by_device(device_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_with_filters(herd_id?: number, device_id?: number, start_date?: string, end_date?: string, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;

package/dist/helpers/session_summaries.js

@@ -0,0 +1,51 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse, } from "../types/requests";
+export async function server_get_session_summaries_by_herd(herd_id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: undefined,
+        end_date_caller: undefined,
+        device_id_caller: undefined,
+        herd_id_caller: herd_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_session_summaries_by_device(device_id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: undefined,
+        end_date_caller: undefined,
+        device_id_caller: device_id,
+        herd_id_caller: undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_session_summaries_with_filters(herd_id, device_id, start_date, end_date, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: start_date || undefined,
+        end_date_caller: end_date || undefined,
+        device_id_caller: device_id || undefined,
+        herd_id_caller: herd_id || undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/hooks/index.d.ts

@@ -7,3 +7,5 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
+export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -7,3 +7,7 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+// RTK Query infinite scroll hooks
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
+// Session summaries and performance hooks
+export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/useHerdData.d.ts

@@ -0,0 +1,167 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { useInfiniteSessionsByHerd, useInfiniteEventsByHerd, useInfiniteArtifactsByHerd } from "./useInfiniteQuery";
+import { IHerdModule } from "../types/herd_module";
+import { ISessionSummary } from "../types/db";
+interface UseHerdDataOptions {
+    sessionsLimit?: number;
+    eventsLimit?: number;
+    artifactsLimit?: number;
+    enableSessions?: boolean;
+    enableEvents?: boolean;
+    enableArtifacts?: boolean;
+    supabase: SupabaseClient;
+}
+interface UseHerdDataReturn {
+    herdModule: IHerdModule | undefined;
+    herd: IHerdModule["herd"] | undefined;
+    devices: IHerdModule["devices"];
+    zones: IHerdModule["zones"];
+    plans: IHerdModule["plans"];
+    layers: IHerdModule["layers"];
+    providers: IHerdModule["providers"];
+    labels: IHerdModule["labels"];
+    userRoles: IHerdModule["user_roles"];
+    sessionSummaries: ISessionSummary | null;
+    timestampLastRefreshed: number | null;
+    sessions: {
+        items: ReturnType<typeof useInfiniteSessionsByHerd>["items"];
+        isLoading: boolean;
+        isLoadingMore: boolean;
+        hasMore: boolean;
+        loadMore: () => void;
+        refetch: () => void;
+        error: any;
+    };
+    events: {
+        items: ReturnType<typeof useInfiniteEventsByHerd>["items"];
+        isLoading: boolean;
+        isLoadingMore: boolean;
+        hasMore: boolean;
+        loadMore: () => void;
+        refetch: () => void;
+        error: any;
+    };
+    artifacts: {
+        items: ReturnType<typeof useInfiniteArtifactsByHerd>["items"];
+        isLoading: boolean;
+        isLoadingMore: boolean;
+        hasMore: boolean;
+        loadMore: () => void;
+        refetch: () => void;
+        error: any;
+    };
+    isInitialLoading: boolean;
+    hasAnyError: boolean;
+}
+/**
+ * Comprehensive hook for accessing herd data from both global store and RTK Query
+ *
+ * @param herdId - The herd ID to fetch data for
+ * @param options - Configuration options for data fetching
+ * @returns Complete herd data with both structural and paginated content
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   herd,
+ *   devices,
+ *   events,
+ *   sessions,
+ *   artifacts,
+ *   sessionSummaries
+ * } = useHerdData(123, {
+ *   supabase,
+ *   eventsLimit: 20,
+ *   enableSessions: true
+ * });
+ *
+ * // Use structural data from global store
+ * console.log(herd.name, devices.length);
+ *
+ * // Use paginated data from RTK Query
+ * console.log(events.items.length, events.hasMore);
+ * if (events.hasMore) {
+ *   events.loadMore();
+ * }
+ *
+ * // Use session summaries
+ * console.log(sessionSummaries?.total_sessions, sessionSummaries?.total_distance_meters);
+ * ```
+ */
+export declare const useHerdData: (herdId: number, options: UseHerdDataOptions) => UseHerdDataReturn;
+/**
+ * Hook for getting just the structural herd data from global store
+ * Useful when you only need basic herd info without paginated content
+ */
+export declare const useHerdStructure: (herdId: number) => {
+    herdModule: IHerdModule | undefined;
+    herd: {
+        created_by: string;
+        description: string;
+        earthranger_domain: string | null;
+        earthranger_token: string | null;
+        id: number;
+        inserted_at: string;
+        is_public: boolean;
+        slug: string;
+        video_publisher_token: string | null;
+        video_server_url: string | null;
+        video_subscriber_token: string | null;
+    } | undefined;
+    devices: import("../types/db").IDevice[];
+    zones: import("../types/db").IZoneWithActions[];
+    plans: {
+        herd_id: number;
+        id: number;
+        inserted_at: string | null;
+        instructions: string;
+        name: string;
+        plan_type: import("..").Database["public"]["Enums"]["plan_type"];
+    }[];
+    layers: {
+        created_at: string;
+        features: import("..").Json;
+        herd_id: number;
+        id: number;
+    }[];
+    providers: {
+        created_at: string;
+        herd_id: number;
+        id: number;
+        key: string | null;
+        source: string;
+        type: string;
+    }[];
+    labels: string[];
+    userRoles: import("../types/db").IUserAndRole[] | null;
+    sessionSummaries: ISessionSummary | null;
+    timestampLastRefreshed: number | null;
+};
+/**
+ * Hook for getting all herd structures (without paginated data)
+ * Useful for dashboard/overview components
+ */
+export declare const useAllHerds: () => {
+    herdModules: IHerdModule[];
+    herds: {
+        created_by: string;
+        description: string;
+        earthranger_domain: string | null;
+        earthranger_token: string | null;
+        id: number;
+        inserted_at: string;
+        is_public: boolean;
+        slug: string;
+        video_publisher_token: string | null;
+        video_server_url: string | null;
+        video_subscriber_token: string | null;
+    }[];
+    totalHerds: number;
+    totalDevices: number;
+    sessionSummaries: {
+        herdId: number;
+        herdSlug: string;
+        summaries: ISessionSummary | null;
+    }[];
+};
+export {};

package/dist/hooks/useHerdData.js

@@ -0,0 +1,153 @@
+import { useSelector } from "react-redux";
+import { useInfiniteSessionsByHerd, useInfiniteEventsByHerd, useInfiniteArtifactsByHerd, } from "./useInfiniteQuery";
+/**
+ * Comprehensive hook for accessing herd data from both global store and RTK Query
+ *
+ * @param herdId - The herd ID to fetch data for
+ * @param options - Configuration options for data fetching
+ * @returns Complete herd data with both structural and paginated content
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   herd,
+ *   devices,
+ *   events,
+ *   sessions,
+ *   artifacts,
+ *   sessionSummaries
+ * } = useHerdData(123, {
+ *   supabase,
+ *   eventsLimit: 20,
+ *   enableSessions: true
+ * });
+ *
+ * // Use structural data from global store
+ * console.log(herd.name, devices.length);
+ *
+ * // Use paginated data from RTK Query
+ * console.log(events.items.length, events.hasMore);
+ * if (events.hasMore) {
+ *   events.loadMore();
+ * }
+ *
+ * // Use session summaries
+ * console.log(sessionSummaries?.total_sessions, sessionSummaries?.total_distance_meters);
+ * ```
+ */
+export const useHerdData = (herdId, options) => {
+    const { sessionsLimit = 20, eventsLimit = 20, artifactsLimit = 20, enableSessions = true, enableEvents = true, enableArtifacts = true, supabase, } = options;
+    // Get structural data from global store
+    const herdModule = useSelector((state) => state.scout.herd_modules.find((hm) => hm.herd.id === herdId));
+    // RTK Query infinite data hooks
+    const sessionsQuery = useInfiniteSessionsByHerd(herdId, {
+        limit: sessionsLimit,
+        enabled: enableSessions,
+        supabase,
+    });
+    const eventsQuery = useInfiniteEventsByHerd(herdId, {
+        limit: eventsLimit,
+        enabled: enableEvents,
+        supabase,
+    });
+    const artifactsQuery = useInfiniteArtifactsByHerd(herdId, {
+        limit: artifactsLimit,
+        enabled: enableArtifacts,
+        supabase,
+    });
+    // Overall loading state - true if any enabled query is loading for the first time
+    const isInitialLoading = (enableSessions &&
+        sessionsQuery.isLoading &&
+        sessionsQuery.items.length === 0) ||
+        (enableEvents && eventsQuery.isLoading && eventsQuery.items.length === 0) ||
+        (enableArtifacts &&
+            artifactsQuery.isLoading &&
+            artifactsQuery.items.length === 0);
+    // Overall error state - true if any enabled query has an error
+    const hasAnyError = (enableSessions && !!sessionsQuery.error) ||
+        (enableEvents && !!eventsQuery.error) ||
+        (enableArtifacts && !!artifactsQuery.error);
+    return {
+        // Global store structural data
+        herdModule,
+        herd: herdModule?.herd,
+        devices: herdModule?.devices || [],
+        zones: herdModule?.zones || [],
+        plans: herdModule?.plans || [],
+        layers: herdModule?.layers || [],
+        providers: herdModule?.providers || [],
+        labels: herdModule?.labels || [],
+        userRoles: herdModule?.user_roles || null,
+        sessionSummaries: herdModule?.session_summaries || null,
+        timestampLastRefreshed: herdModule?.timestamp_last_refreshed || null,
+        // RTK Query paginated data
+        sessions: {
+            items: sessionsQuery.items,
+            isLoading: sessionsQuery.isLoading,
+            isLoadingMore: sessionsQuery.isLoadingMore,
+            hasMore: sessionsQuery.hasMore,
+            loadMore: sessionsQuery.loadMore,
+            refetch: sessionsQuery.refetch,
+            error: sessionsQuery.error,
+        },
+        events: {
+            items: eventsQuery.items,
+            isLoading: eventsQuery.isLoading,
+            isLoadingMore: eventsQuery.isLoadingMore,
+            hasMore: eventsQuery.hasMore,
+            loadMore: eventsQuery.loadMore,
+            refetch: eventsQuery.refetch,
+            error: eventsQuery.error,
+        },
+        artifacts: {
+            items: artifactsQuery.items,
+            isLoading: artifactsQuery.isLoading,
+            isLoadingMore: artifactsQuery.isLoadingMore,
+            hasMore: artifactsQuery.hasMore,
+            loadMore: artifactsQuery.loadMore,
+            refetch: artifactsQuery.refetch,
+            error: artifactsQuery.error,
+        },
+        // Overall states
+        isInitialLoading,
+        hasAnyError,
+    };
+};
+/**
+ * Hook for getting just the structural herd data from global store
+ * Useful when you only need basic herd info without paginated content
+ */
+export const useHerdStructure = (herdId) => {
+    const herdModule = useSelector((state) => state.scout.herd_modules.find((hm) => hm.herd.id === herdId));
+    return {
+        herdModule,
+        herd: herdModule?.herd,
+        devices: herdModule?.devices || [],
+        zones: herdModule?.zones || [],
+        plans: herdModule?.plans || [],
+        layers: herdModule?.layers || [],
+        providers: herdModule?.providers || [],
+        labels: herdModule?.labels || [],
+        userRoles: herdModule?.user_roles || null,
+        sessionSummaries: herdModule?.session_summaries || null,
+        timestampLastRefreshed: herdModule?.timestamp_last_refreshed || null,
+    };
+};
+/**
+ * Hook for getting all herd structures (without paginated data)
+ * Useful for dashboard/overview components
+ */
+export const useAllHerds = () => {
+    const herdModules = useSelector((state) => state.scout.herd_modules);
+    return {
+        herdModules,
+        herds: herdModules.map((hm) => hm.herd),
+        totalHerds: herdModules.length,
+        totalDevices: herdModules.reduce((sum, hm) => sum + hm.devices.length, 0),
+        sessionSummaries: herdModules.map((hm) => ({
+            herdId: hm.herd.id,
+            herdSlug: hm.herd.slug,
+            summaries: hm.session_summaries,
+        })),
+    };
+};

package/dist/hooks/useInfiniteQuery.d.ts

@@ -0,0 +1,24 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+interface UseInfiniteScrollOptions {
+    limit?: number;
+    enabled?: boolean;
+    supabase: SupabaseClient;
+}
+interface InfiniteScrollData<T> {
+    items: T[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    loadMore: () => void;
+    refetch: () => void;
+    error: any;
+}
+export declare const useInfiniteSessionsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<ISessionWithCoordinates>;
+export declare const useInfiniteSessionsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<ISessionWithCoordinates>;
+export declare const useInfiniteEventsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IEventAndTagsPrettyLocation>;
+export declare const useInfiniteEventsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IEventAndTagsPrettyLocation>;
+export declare const useInfiniteArtifactsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IArtifactWithMediaUrl>;
+export declare const useInfiniteArtifactsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IArtifactWithMediaUrl>;
+export declare const useIntersectionObserver: (callback: () => void, options?: IntersectionObserverInit) => import("react").Dispatch<import("react").SetStateAction<Element | null>>;
+export {};