@adventurelabs/scout-core 1.4.18 → 1.4.19

package/dist/helpers/artifacts.d.ts

@@ -1,6 +1,7 @@
 import { IArtifact, IArtifactWithMediaUrl, ArtifactInsert, ArtifactUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_artifact_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl | null>>;
 export declare function server_get_artifacts_by_herd(herd_id: number, limit?: number, offset?: number, options?: {
     start_timestamp?: string;
     end_timestamp?: string;

package/dist/helpers/artifacts.js

@@ -1,7 +1,30 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatch } from "./storage";
+import { generateSignedUrlsBatch, generateSignedUrl } from "./storage";
+export async function server_get_artifact_by_id(id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("artifacts")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const artifact = data;
+    let media_url = null;
+    if (artifact.file_path) {
+        media_url = await generateSignedUrl(artifact.file_path, undefined, client);
+    }
+    return IWebResponse.success({
+        ...artifact,
+        media_url,
+    }).to_compatible();
+}
 export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset = 0, options) {
     const supabase = options?.client || (await newServerClient());
     const { data, error } = await supabase.rpc("get_artifacts_for_herd", {

package/dist/helpers/events.d.ts

@@ -1,7 +1,8 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
-import { IEvent, EventInsert, EventUpdate } from "../types/db";
+import { IEvent, IEventWithMediaUrl, EventInsert, EventUpdate } from "../types/db";
 import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_event_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
 export declare function server_get_total_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
 export declare function server_insert_event(events: EventInsert | EventInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_update_event(events: (EventUpdate & {

package/dist/helpers/events.js

@@ -2,6 +2,30 @@
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
+import { generateSignedUrl } from "./storage";
+export async function server_get_event_by_id(id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("events")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const event = data;
+    let media_url = null;
+    if (event.file_path) {
+        media_url = await generateSignedUrl(event.file_path, undefined, client);
+    }
+    return IWebResponse.success({
+        ...event,
+        media_url,
+    }).to_compatible();
+}
 // function to get total number of events for a herd
 export async function server_get_total_events_by_herd(herd_id, sessions_visibility) {
     const supabase = await newServerClient();

package/dist/helpers/tags.js

@@ -419,6 +419,7 @@ export async function get_event_and_tags_by_event_id(event_id) {
                 y: tag.y,
                 class: tag.class,
                 timestamp_observation: tag.timestamp_observation,
+                frame_index: tag.frame_index ?? null,
                 origin_location: tag.origin_location ?? null,
                 origin_pitch: tag.origin_pitch,
                 origin_heading: tag.origin_heading,

package/dist/hooks/useInfiniteQuery.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem } from "../types/db";
 interface UseInfiniteScrollOptions {
     limit?: number;
     enabled?: boolean;
@@ -20,5 +20,7 @@ export declare const useInfiniteEventsByHerd: (herdId: number, options: UseInfin
 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 useInfiniteFeedByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
+export declare const useInfiniteFeedByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
 export declare const useIntersectionObserver: (callback: () => void, options?: IntersectionObserverInit) => import("react").Dispatch<import("react").SetStateAction<Element | null>>;
 export {};

package/dist/hooks/useInfiniteQuery.js

@@ -1,5 +1,5 @@
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
-import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, } from "../store/api";
+import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, } from "../store/api";
 // =====================================================
 // SESSIONS INFINITE SCROLL HOOKS
 // =====================================================
@@ -407,6 +407,127 @@ export const useInfiniteArtifactsByDevice = (deviceId, options) => {
         error: currentQuery.error,
     };
 };
+const feedCursorEq = (a, b) => {
+    if (a === null && b === null)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.timestamp === b.timestamp && a.id === b.id && a.feed_type === b.feed_type;
+};
+export const useInfiniteFeedByHerd = (herdId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const prevHerdIdRef = useRef();
+    const currentQuery = useGetFeedInfiniteByHerdQuery({
+        herdId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, { skip: !options.enabled || !herdId });
+    useEffect(() => {
+        if (prevHerdIdRef.current !== undefined &&
+            prevHerdIdRef.current !== herdId &&
+            options.enabled &&
+            herdId) {
+            setPages([]);
+            setCurrentCursor(null);
+        }
+        prevHerdIdRef.current = herdId;
+    }, [herdId, options.enabled]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => feedCursorEq(p.cursor, currentCursor));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.items },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((p) => p.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore ?? false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
+export const useInfiniteFeedByDevice = (deviceId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const prevDeviceIdRef = useRef();
+    const currentQuery = useGetFeedInfiniteByDeviceQuery({
+        deviceId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, { skip: !options.enabled || !deviceId });
+    useEffect(() => {
+        if (prevDeviceIdRef.current !== undefined &&
+            prevDeviceIdRef.current !== deviceId &&
+            options.enabled &&
+            deviceId) {
+            setPages([]);
+            setCurrentCursor(null);
+        }
+        prevDeviceIdRef.current = deviceId;
+    }, [deviceId, options.enabled]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => feedCursorEq(p.cursor, currentCursor));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.items },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((p) => p.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore ?? false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
 // =====================================================
 // INTERSECTION OBSERVER HOOK FOR AUTO-LOADING
 // =====================================================

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -927,6 +927,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 conf: number;
                 detector: string;
                 event_id: number | null;
+                frame_index: number | null;
                 height: number;
                 id: number;
                 inserted_at: string;
@@ -953,6 +954,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 conf: number;
                 detector?: string;
                 event_id?: number | null;
+                frame_index?: number | null;
                 height?: number;
                 id?: number;
                 inserted_at?: string;
@@ -979,6 +981,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 conf?: number;
                 detector?: string;
                 event_id?: number | null;
+                frame_index?: number | null;
                 height?: number;
                 id?: number;
                 inserted_at?: string;
@@ -1694,6 +1697,38 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 isSetofReturn: true;
             };
         };
+        get_feed_infinite_by_device: {
+            Args: {
+                cursor_feed_type?: string;
+                cursor_id?: number;
+                cursor_timestamp?: string;
+                device_id_caller: number;
+                limit_caller?: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["feed_item"][];
+            SetofOptions: {
+                from: "*";
+                to: "feed_item";
+                isOneToOne: false;
+                isSetofReturn: true;
+            };
+        };
+        get_feed_infinite_by_herd: {
+            Args: {
+                cursor_feed_type?: string;
+                cursor_id?: number;
+                cursor_timestamp?: string;
+                herd_id_caller: number;
+                limit_caller?: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["feed_item"][];
+            SetofOptions: {
+                from: "*";
+                to: "feed_item";
+                isOneToOne: false;
+                isSetofReturn: true;
+            };
+        };
         get_health_metrics_summary: {
             Args: {
                 p_device_id: number;
@@ -2066,6 +2101,13 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             is_public: boolean | null;
             tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
         };
+        feed_item: {
+            feed_type: string | null;
+            sort_ts: string | null;
+            sort_id: number | null;
+            event_data: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"] | null;
+            artifact_data: Database["public"]["Tables"]["artifacts"]["Row"] | null;
+        };
         herds_pretty_location: {
             id: number | null;
             inserted_at: string | null;
@@ -2125,6 +2167,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             y: number | null;
             class: string | null;
             timestamp_observation: string | null;
+            frame_index: number | null;
             origin_location: unknown;
             origin_pitch: number | null;
             origin_heading: number | null;

package/dist/store/api.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem } from "../types/db";
 export interface InfiniteQueryArgs {
     herdId?: number;
     deviceId?: number;
@@ -33,6 +33,16 @@ export interface ArtifactsInfiniteResponse {
     } | null;
     hasMore: boolean;
 }
+export interface FeedCursor {
+    timestamp: string;
+    id: number;
+    feed_type: string;
+}
+export interface FeedInfiniteResponse {
+    items: IFeedItem[];
+    nextCursor: FeedCursor | null;
+    hasMore: boolean;
+}
 export declare const scoutApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, {
     getSessionsInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<InfiniteQueryArgs & {
         supabase: SupabaseClient;
@@ -52,6 +62,18 @@ export declare const scoutApi: import("@reduxjs/toolkit/query").Api<import("@red
     getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<InfiniteQueryArgs & {
         supabase: SupabaseClient;
     }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", ArtifactsInfiniteResponse, "scoutApi", unknown>;
+    getFeedInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>;
+    getFeedInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>;
 }, "scoutApi", "Session" | "Event" | "Artifact", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
 export declare const useGetSessionsInfiniteByHerdQuery: <R extends Record<string, any> = import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
     status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
@@ -965,4 +987,368 @@ export declare const useGetSessionsInfiniteByHerdQuery: <R extends Record<string
     refetch: () => import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<InfiniteQueryArgs & {
         supabase: SupabaseClient;
     }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", ArtifactsInfiniteResponse, "scoutApi", unknown>>;
+}, useGetFeedInfiniteByHerdQuery: <R extends Record<string, any> = import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+    status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+    originalArgs?: undefined | undefined;
+    data?: undefined | undefined;
+    error?: undefined | undefined;
+    requestId?: undefined | undefined;
+    endpointName?: string | undefined;
+    startedTimeStamp?: undefined | undefined;
+    fulfilledTimeStamp?: undefined | undefined;
+} & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "isUninitialized"> & {
+    isUninitialized: true;
+}) | import("@reduxjs/toolkit/query").TSHelpersOverride<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    herdId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    herdId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "fulfilledTimeStamp">>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    herdId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "fulfilledTimeStamp" | "currentData">>) | ({
+    isError: true;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    herdId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "error">>)>> & {
+    status: import("@reduxjs/toolkit/query").QueryStatus;
+}>(arg: {
+    herdId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+} | typeof import("@reduxjs/toolkit/query").skipToken, options?: (import("@reduxjs/toolkit/query").SubscriptionOptions & {
+    skip?: boolean;
+    refetchOnMountOrArgChange?: boolean | number;
+} & {
+    skip?: boolean;
+    selectFromResult?: ((state: import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+        status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+        originalArgs?: undefined | undefined;
+        data?: undefined | undefined;
+        error?: undefined | undefined;
+        requestId?: undefined | undefined;
+        endpointName?: string | undefined;
+        startedTimeStamp?: undefined | undefined;
+        fulfilledTimeStamp?: undefined | undefined;
+    } & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "isUninitialized"> & {
+        isUninitialized: true;
+    }) | import("@reduxjs/toolkit/query").TSHelpersOverride<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, {
+        isLoading: true;
+        isFetching: boolean;
+        data: undefined;
+    } | ({
+        isSuccess: true;
+        isFetching: true;
+        error: undefined;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "fulfilledTimeStamp">>) | ({
+        isSuccess: true;
+        isFetching: false;
+        error: undefined;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "fulfilledTimeStamp" | "currentData">>) | ({
+        isError: true;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "error">>)>> & {
+        status: import("@reduxjs/toolkit/query").QueryStatus;
+    }) => R) | undefined;
+}) | undefined) => [R][R extends any ? 0 : never] & {
+    refetch: () => import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<{
+        herdId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>>;
+}, useGetFeedInfiniteByDeviceQuery: <R extends Record<string, any> = import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+    status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+    originalArgs?: undefined | undefined;
+    data?: undefined | undefined;
+    error?: undefined | undefined;
+    requestId?: undefined | undefined;
+    endpointName?: string | undefined;
+    startedTimeStamp?: undefined | undefined;
+    fulfilledTimeStamp?: undefined | undefined;
+} & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "isUninitialized"> & {
+    isUninitialized: true;
+}) | import("@reduxjs/toolkit/query").TSHelpersOverride<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    deviceId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    deviceId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "fulfilledTimeStamp">>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    deviceId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "fulfilledTimeStamp" | "currentData">>) | ({
+    isError: true;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    deviceId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+    currentData?: FeedInfiniteResponse | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "error">>)>> & {
+    status: import("@reduxjs/toolkit/query").QueryStatus;
+}>(arg: {
+    deviceId: number;
+    limit?: number;
+    cursor?: FeedCursor | null;
+    supabase: SupabaseClient;
+} | typeof import("@reduxjs/toolkit/query").skipToken, options?: (import("@reduxjs/toolkit/query").SubscriptionOptions & {
+    skip?: boolean;
+    refetchOnMountOrArgChange?: boolean | number;
+} & {
+    skip?: boolean;
+    selectFromResult?: ((state: import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+        status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+        originalArgs?: undefined | undefined;
+        data?: undefined | undefined;
+        error?: undefined | undefined;
+        requestId?: undefined | undefined;
+        endpointName?: string | undefined;
+        startedTimeStamp?: undefined | undefined;
+        fulfilledTimeStamp?: undefined | undefined;
+    } & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "isUninitialized"> & {
+        isUninitialized: true;
+    }) | import("@reduxjs/toolkit/query").TSHelpersOverride<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, {
+        isLoading: true;
+        isFetching: boolean;
+        data: undefined;
+    } | ({
+        isSuccess: true;
+        isFetching: true;
+        error: undefined;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "fulfilledTimeStamp">>) | ({
+        isSuccess: true;
+        isFetching: false;
+        error: undefined;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "fulfilledTimeStamp" | "currentData">>) | ({
+        isError: true;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>> & {
+        currentData?: FeedInfiniteResponse | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "error">>)>> & {
+        status: import("@reduxjs/toolkit/query").QueryStatus;
+    }) => R) | undefined;
+}) | undefined) => [R][R extends any ? 0 : never] & {
+    refetch: () => import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<{
+        deviceId: number;
+        limit?: number;
+        cursor?: FeedCursor | null;
+        supabase: SupabaseClient;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", FeedInfiniteResponse, "scoutApi", unknown>>;
 };

package/dist/store/api.js

@@ -430,7 +430,174 @@ export const scoutApi = createApi({
                 ]
                 : [{ type: "Artifact", id: "LIST" }],
         }),
+        // =====================================================
+        // FEED INFINITE QUERIES (merged events + artifacts)
+        // =====================================================
+        getFeedInfiniteByHerd: builder.query({
+            serializeQueryArgs,
+            async queryFn({ herdId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!herdId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Herd ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_feed_infinite_by_herd", {
+                        herd_id_caller: herdId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp ?? null,
+                        cursor_id: cursor?.id ?? null,
+                        cursor_feed_type: cursor?.feed_type ?? null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const rows = data || [];
+                    const hasMore = rows.length > limit;
+                    const resultRows = hasMore ? rows.slice(0, limit) : rows;
+                    const uniqueFilePaths = Array.from(new Set(resultRows.flatMap((row) => {
+                        const paths = [];
+                        if (row.event_data?.file_path)
+                            paths.push(row.event_data.file_path);
+                        if (row.artifact_data?.file_path)
+                            paths.push(row.artifact_data.file_path);
+                        return paths;
+                    })));
+                    let urlMap = new Map();
+                    if (uniqueFilePaths.length > 0) {
+                        try {
+                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
+                            urlResults.forEach((url, index) => {
+                                if (url)
+                                    urlMap.set(uniqueFilePaths[index], url);
+                            });
+                        }
+                        catch (urlError) {
+                            console.warn("Failed to generate signed URLs for feed:", urlError);
+                        }
+                    }
+                    const items = resultRows.map((row) => ({
+                        ...row,
+                        event_data: row.event_data
+                            ? {
+                                ...row.event_data,
+                                media_url: row.event_data.file_path
+                                    ? urlMap.get(row.event_data.file_path) ?? null
+                                    : null,
+                            }
+                            : null,
+                        artifact_data: row.artifact_data
+                            ? {
+                                ...row.artifact_data,
+                                media_url: row.artifact_data.file_path
+                                    ? urlMap.get(row.artifact_data.file_path) ?? null
+                                    : null,
+                            }
+                            : null,
+                    }));
+                    const last = resultRows[resultRows.length - 1];
+                    const nextCursor = hasMore && last
+                        ? {
+                            timestamp: last.sort_ts ?? "",
+                            id: last.sort_id ?? 0,
+                            feed_type: last.feed_type ?? "",
+                        }
+                        : null;
+                    return {
+                        data: { items, nextCursor, hasMore },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: () => [{ type: "Event", id: "LIST" }, { type: "Artifact", id: "LIST" }],
+        }),
+        getFeedInfiniteByDevice: builder.query({
+            serializeQueryArgs,
+            async queryFn({ deviceId, limit = 20, cursor, supabase }) {
+                try {
+                    if (!deviceId) {
+                        return {
+                            error: { status: "CUSTOM_ERROR", error: "Device ID is required" },
+                        };
+                    }
+                    const { data, error } = await supabase.rpc("get_feed_infinite_by_device", {
+                        device_id_caller: deviceId,
+                        limit_caller: limit + 1,
+                        cursor_timestamp: cursor?.timestamp ?? null,
+                        cursor_id: cursor?.id ?? null,
+                        cursor_feed_type: cursor?.feed_type ?? null,
+                    });
+                    if (error) {
+                        return {
+                            error: { status: "SUPABASE_ERROR", error: error.message },
+                        };
+                    }
+                    const rows = data || [];
+                    const hasMore = rows.length > limit;
+                    const resultRows = hasMore ? rows.slice(0, limit) : rows;
+                    const uniqueFilePaths = Array.from(new Set(resultRows.flatMap((row) => {
+                        const paths = [];
+                        if (row.event_data?.file_path)
+                            paths.push(row.event_data.file_path);
+                        if (row.artifact_data?.file_path)
+                            paths.push(row.artifact_data.file_path);
+                        return paths;
+                    })));
+                    let urlMap = new Map();
+                    if (uniqueFilePaths.length > 0) {
+                        try {
+                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
+                            urlResults.forEach((url, index) => {
+                                if (url)
+                                    urlMap.set(uniqueFilePaths[index], url);
+                            });
+                        }
+                        catch (urlError) {
+                            console.warn("Failed to generate signed URLs for feed:", urlError);
+                        }
+                    }
+                    const items = resultRows.map((row) => ({
+                        ...row,
+                        event_data: row.event_data
+                            ? {
+                                ...row.event_data,
+                                media_url: row.event_data.file_path
+                                    ? urlMap.get(row.event_data.file_path) ?? null
+                                    : null,
+                            }
+                            : null,
+                        artifact_data: row.artifact_data
+                            ? {
+                                ...row.artifact_data,
+                                media_url: row.artifact_data.file_path
+                                    ? urlMap.get(row.artifact_data.file_path) ?? null
+                                    : null,
+                            }
+                            : null,
+                    }));
+                    const last = resultRows[resultRows.length - 1];
+                    const nextCursor = hasMore && last
+                        ? {
+                            timestamp: last.sort_ts ?? "",
+                            id: last.sort_id ?? 0,
+                            feed_type: last.feed_type ?? "",
+                        }
+                        : null;
+                    return {
+                        data: { items, nextCursor, hasMore },
+                    };
+                }
+                catch (err) {
+                    return { error: { status: "FETCH_ERROR", error: String(err) } };
+                }
+            },
+            providesTags: () => [{ type: "Event", id: "LIST" }, { type: "Artifact", id: "LIST" }],
+        }),
     }),
 });
 // Export hooks for usage in functional components
-export const { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, } = scoutApi;
+export const { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, } = scoutApi;

package/dist/store/configureStore.d.ts

@@ -19,6 +19,18 @@ export declare const configureScoutStore: () => import("@reduxjs/toolkit").Enhan
         getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
             supabase: import("@supabase/supabase-js").SupabaseClient;
         }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        getFeedInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<{
+            herdId: number;
+            limit?: number;
+            cursor?: import("./api").FeedCursor | null;
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
+        getFeedInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<{
+            deviceId: number;
+            limit?: number;
+            cursor?: import("./api").FeedCursor | null;
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
     }, "Session" | "Event" | "Artifact", "scoutApi">;
 }, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
     dispatch: import("redux-thunk").ThunkDispatch<{
@@ -42,6 +54,18 @@ export declare const configureScoutStore: () => import("@reduxjs/toolkit").Enhan
             getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
                 supabase: import("@supabase/supabase-js").SupabaseClient;
             }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+            getFeedInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<{
+                herdId: number;
+                limit?: number;
+                cursor?: import("./api").FeedCursor | null;
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
+            getFeedInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<{
+                deviceId: number;
+                limit?: number;
+                cursor?: import("./api").FeedCursor | null;
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
         }, "Session" | "Event" | "Artifact", "scoutApi">;
     }, undefined, import("redux").UnknownAction>;
 }>, import("redux").StoreEnhancer]>>;
@@ -68,6 +92,18 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
             supabase: import("@supabase/supabase-js").SupabaseClient;
         }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+        getFeedInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<{
+            herdId: number;
+            limit?: number;
+            cursor?: import("./api").FeedCursor | null;
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
+        getFeedInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<{
+            deviceId: number;
+            limit?: number;
+            cursor?: import("./api").FeedCursor | null;
+            supabase: import("@supabase/supabase-js").SupabaseClient;
+        }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
     }, "Session" | "Event" | "Artifact", "scoutApi">;
 }, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
     dispatch: import("redux-thunk").ThunkDispatch<{
@@ -91,6 +127,18 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
             getArtifactsInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<import("./api").InfiniteQueryArgs & {
                 supabase: import("@supabase/supabase-js").SupabaseClient;
             }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").ArtifactsInfiniteResponse, "scoutApi", unknown>;
+            getFeedInfiniteByHerd: import("@reduxjs/toolkit/query").QueryDefinition<{
+                herdId: number;
+                limit?: number;
+                cursor?: import("./api").FeedCursor | null;
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
+            getFeedInfiniteByDevice: import("@reduxjs/toolkit/query").QueryDefinition<{
+                deviceId: number;
+                limit?: number;
+                cursor?: import("./api").FeedCursor | null;
+                supabase: import("@supabase/supabase-js").SupabaseClient;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Session" | "Event" | "Artifact", import("./api").FeedInfiniteResponse, "scoutApi", unknown>;
         }, "Session" | "Event" | "Artifact", "scoutApi">;
     }, undefined, import("redux").UnknownAction>;
 }>, import("redux").StoreEnhancer]>>;

package/dist/types/db.d.ts

@@ -33,6 +33,9 @@ export type IHealthMetricSummaryRow = Database["public"]["Functions"]["get_healt
 export type IArtifactWithMediaUrl = IArtifact & {
     media_url?: string | null;
 };
+export type IEventWithMediaUrl = IEvent & {
+    media_url?: string | null;
+};
 export type IVersionsSoftwareWithBuildUrl = IVersionsSoftware & {
     build_artifact_url?: string | null;
 };
@@ -75,6 +78,16 @@ export type IDevicePrettyLocation = Database["public"]["CompositeTypes"]["device
 export type IEventAndTagsPrettyLocation = Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"];
 export type IZonesAndActionsPrettyLocation = Database["public"]["CompositeTypes"]["zones_and_actions_pretty_location"];
 export type IHerdPrettyLocation = Database["public"]["CompositeTypes"]["herds_pretty_location"];
+export type IFeedItemRow = Database["public"]["CompositeTypes"]["feed_item"];
+export type IFeedItem = {
+    feed_type: string | null;
+    sort_ts: string | null;
+    sort_id: number | null;
+    event_data: (IEventAndTagsPrettyLocation & {
+        media_url?: string | null;
+    }) | null;
+    artifact_data: IArtifactWithMediaUrl | null;
+};
 export type ISessionWithCoordinates = Database["public"]["CompositeTypes"]["session_with_coordinates"];
 export type IConnectivityWithCoordinates = Database["public"]["CompositeTypes"]["connectivity_with_coordinates"];
 export type IDeviceHeartbeatAnalysis = Database["public"]["CompositeTypes"]["device_heartbeat_analysis"];

package/dist/types/supabase.d.ts

@@ -974,6 +974,7 @@ export type Database = {
                     conf: number;
                     detector: string;
                     event_id: number | null;
+                    frame_index: number | null;
                     height: number;
                     id: number;
                     inserted_at: string;
@@ -1000,6 +1001,7 @@ export type Database = {
                     conf: number;
                     detector?: string;
                     event_id?: number | null;
+                    frame_index?: number | null;
                     height?: number;
                     id?: number;
                     inserted_at?: string;
@@ -1026,6 +1028,7 @@ export type Database = {
                     conf?: number;
                     detector?: string;
                     event_id?: number | null;
+                    frame_index?: number | null;
                     height?: number;
                     id?: number;
                     inserted_at?: string;
@@ -1761,6 +1764,38 @@ export type Database = {
                     isSetofReturn: true;
                 };
             };
+            get_feed_infinite_by_device: {
+                Args: {
+                    cursor_feed_type?: string;
+                    cursor_id?: number;
+                    cursor_timestamp?: string;
+                    device_id_caller: number;
+                    limit_caller?: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["feed_item"][];
+                SetofOptions: {
+                    from: "*";
+                    to: "feed_item";
+                    isOneToOne: false;
+                    isSetofReturn: true;
+                };
+            };
+            get_feed_infinite_by_herd: {
+                Args: {
+                    cursor_feed_type?: string;
+                    cursor_id?: number;
+                    cursor_timestamp?: string;
+                    herd_id_caller: number;
+                    limit_caller?: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["feed_item"][];
+                SetofOptions: {
+                    from: "*";
+                    to: "feed_item";
+                    isOneToOne: false;
+                    isSetofReturn: true;
+                };
+            };
             get_health_metrics_summary: {
                 Args: {
                     p_device_id: number;
@@ -2133,6 +2168,13 @@ export type Database = {
                 is_public: boolean | null;
                 tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
             };
+            feed_item: {
+                feed_type: string | null;
+                sort_ts: string | null;
+                sort_id: number | null;
+                event_data: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"] | null;
+                artifact_data: Database["public"]["Tables"]["artifacts"]["Row"] | null;
+            };
             herds_pretty_location: {
                 id: number | null;
                 inserted_at: string | null;
@@ -2192,6 +2234,7 @@ export type Database = {
                 y: number | null;
                 class: string | null;
                 timestamp_observation: string | null;
+                frame_index: number | null;
                 origin_location: unknown;
                 origin_pitch: number | null;
                 origin_heading: number | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.4.18",
+  "version": "1.4.19",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",