@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/tags.js

@@ -1,589 +1,43 @@
-"use server";
-// add tag to db
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { generateSignedUrlsBatchWithClient, generateSignedUrlWithClient, } from "./storage_internal";
-import { isNonEmptyStorageFilePath } from "./storagePath";
-// Helper functions to extract coordinates from location field
-function extractLatitude(location) {
-    try {
-        if (typeof location === "object" && location !== null) {
-            if ("coordinates" in location && Array.isArray(location.coordinates)) {
-                return location.coordinates[1]; // latitude is second coordinate
-            }
-            if ("y" in location) {
-                return location.y;
-            }
-        }
-        if (typeof location === "string") {
-            const match = location.match(/Point\(([^)]+)\)/);
-            if (match) {
-                const coords = match[1].split(" ").map(Number);
-                if (coords.length === 2) {
-                    return coords[1]; // latitude is second coordinate
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.warn("Error extracting latitude:", error);
-    }
-    return null;
-}
-function extractLongitude(location) {
-    try {
-        if (typeof location === "object" && location !== null) {
-            if ("coordinates" in location && Array.isArray(location.coordinates)) {
-                return location.coordinates[0]; // longitude is first coordinate
-            }
-            if ("x" in location) {
-                return location.x;
-            }
-        }
-        if (typeof location === "string") {
-            const match = location.match(/Point\(([^)]+)\)/);
-            if (match) {
-                const coords = match[1].split(" ").map(Number);
-                if (coords.length === 2) {
-                    return coords[0]; // longitude is first coordinate
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.warn("Error extracting longitude:", error);
-    }
-    return null;
-}
-function rpcModelIdsParam(model_ids) {
-    if (model_ids != null && model_ids.length > 0) {
-        return { model_ids_caller: model_ids };
-    }
-    return {};
-}
-// Test function to verify individual event loading works
-export async function test_event_loading(device_id) {
-    try {
-        console.log(`[Event Test] Testing individual event loading for device ${device_id}`);
-        const events_response = await server_get_events_and_tags_for_device(device_id, 1);
-        if (events_response.status === EnumWebResponse.SUCCESS) {
-            console.log(`[Event Test] Successfully loaded ${events_response.data?.length || 0} events for device ${device_id}`);
-            return true;
-        }
-        else {
-            console.error(`[Event Test] Failed to load events for device ${device_id}:`, events_response.msg);
-            return false;
-        }
-    }
-    catch (error) {
-        console.error(`[Event Test] Failed to load events for device ${device_id}:`, error);
-        return false;
-    }
-}
+import { create_tags_query, delete_tags_by_ids_query, get_event_and_tags_by_event_id_query, get_events_and_tags_for_device_query, get_events_and_tags_for_devices_batch_query, get_minimal_subjects_for_artifact_query, get_more_events_with_tags_by_herd_query, get_tags_for_artifact_by_frame_index_query, get_tags_for_artifact_by_subject_id_query, get_tags_for_artifact_query, get_tags_for_event_query, update_tags_query, } from "./tags.queries";
 export async function server_create_tags(tags) {
-    const supabase = await newServerClient();
-    // remove id key from tags
-    const formatted_tags = tags.map((tag) => {
-        const { id, ...rest } = tag;
-        return {
-            ...rest,
-            observation_type: rest.observation_type,
-        };
-    });
-    const { data, error } = await supabase
-        .from("tags")
-        .insert(formatted_tags)
-        .select("*");
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return create_tags_query(await newServerClient(), tags);
 }
 export async function server_delete_tags_by_ids(tag_ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase.from("tags").delete().in("id", tag_ids);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: false,
-        };
-    }
-    else {
-        return IWebResponse.success(true).to_compatible();
-    }
+    return delete_tags_by_ids_query(await newServerClient(), tag_ids);
 }
 export async function server_update_tags(tags) {
-    const supabase = await newServerClient();
-    // Update each tag individually since we need to preserve the id
-    const updatedTags = [];
-    for (const tag of tags) {
-        const { id, inserted_at: _ignoredInsertedAt, ...updateData } = tag;
-        const { data, error } = await supabase
-            .from("tags")
-            .update({
-            ...updateData,
-            observation_type: updateData.observation_type,
-        })
-            .eq("id", id)
-            .select("*")
-            .single();
-        if (error) {
-            return {
-                status: EnumWebResponse.ERROR,
-                msg: error.message,
-                data: null,
-            };
-        }
-        if (data) {
-            updatedTags.push(data);
-        }
-    }
-    return IWebResponse.success(updatedTags).to_compatible();
+    return update_tags_query(await newServerClient(), tags);
 }
 export async function server_get_more_events_with_tags_by_herd(herd_id, offset, page_count = 10) {
-    const from = offset * page_count;
-    const supabase = await newServerClient();
-    // make rpc call to get_events_and_tags_for_herd(herd_id, offset, limit)
-    const { data, error } = await supabase.rpc("get_events_and_tags_for_herd", {
-        herd_id_caller: herd_id,
-        offset_caller: from,
-        limit_caller: page_count,
-    });
-    if (error) {
-        console.warn("Error fetching events with tags by herd:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // iterate through data if tags contains null, remove it
-    const filtered_data = (data || []).map((event) => {
-        if (!event.tags)
-            return event;
-        event.tags = event.tags.filter((tag) => tag !== null);
-        return event;
-    });
-    // Generate signed URLs for events
-    const filePaths = filtered_data
-        .map((event) => event.file_path)
-        .filter(isNonEmptyStorageFilePath);
-    let eventsWithSignedUrls = filtered_data;
-    if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths, undefined);
-        const urlMap = new Map();
-        filePaths.forEach((path, index) => {
-            urlMap.set(path, signedUrls[index]);
-        });
-        eventsWithSignedUrls = filtered_data.map((event) => ({
-            ...event,
-            media_url: isNonEmptyStorageFilePath(event.file_path)
-                ? urlMap.get(event.file_path) ?? null
-                : null,
-        }));
-    }
-    return IWebResponse.success(eventsWithSignedUrls).to_compatible();
+    return get_more_events_with_tags_by_herd_query(await newServerClient(), herd_id, offset, page_count);
 }
 export async function server_get_events_and_tags_for_device(device_id, limit = 3) {
-    const supabase = await newServerClient();
-    // make rpc call to get_events_and_tags_for_device(device_id, limit)
-    const { data, error } = await supabase.rpc("get_events_and_tags_for_device", {
-        device_id_caller: device_id,
-        limit_caller: limit,
-    });
-    if (error) {
-        console.warn("Error fetching recent events with tags by device:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Generate signed URLs for events
-    const eventData = data || [];
-    const filePaths = eventData
-        .map((event) => event.file_path)
-        .filter(isNonEmptyStorageFilePath);
-    let eventsWithSignedUrls = eventData;
-    if (filePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatchWithClient(supabase, filePaths, undefined);
-        const urlMap = new Map();
-        filePaths.forEach((path, index) => {
-            urlMap.set(path, signedUrls[index]);
-        });
-        eventsWithSignedUrls = eventData.map((event) => ({
-            ...event,
-            media_url: isNonEmptyStorageFilePath(event.file_path)
-                ? urlMap.get(event.file_path) ?? null
-                : null,
-        }));
-    }
-    return IWebResponse.success(eventsWithSignedUrls).to_compatible();
+    return get_events_and_tags_for_device_query(await newServerClient(), device_id, limit);
 }
 export async function server_get_events_and_tags_for_devices_batch(device_ids, limit = 1) {
-    const supabase = await newServerClient();
-    // Use single RPC call for all devices
-    const { data, error } = await supabase.rpc("get_events_and_tags_for_devices_batch", {
-        device_ids: device_ids,
-        limit_per_device: limit,
-    });
-    if (error) {
-        console.error(`[Events Batch] Database error:`, error.message);
-        console.log(`[Events Batch] Falling back to individual calls...`);
-        // Fallback to individual event loading
-        const result = {};
-        const promises = device_ids.map(async (device_id) => {
-            try {
-                const events_response = await server_get_events_and_tags_for_device(device_id, limit);
-                if (events_response.status === EnumWebResponse.SUCCESS &&
-                    events_response.data) {
-                    result[device_id] = events_response.data;
-                }
-                else {
-                    result[device_id] = [];
-                }
-            }
-            catch (err) {
-                console.warn(`[Events Batch] Failed for device ${device_id}:`, err);
-                result[device_id] = [];
-            }
-        });
-        await Promise.all(promises);
-        return IWebResponse.success(result).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.success({}).to_compatible();
-    }
-    // Group events by device_id
-    const eventsByDevice = {};
-    data.forEach((row) => {
-        const device_id = row.device_id;
-        if (!eventsByDevice[device_id]) {
-            eventsByDevice[device_id] = [];
-        }
-        // Create event object from the event_and_tags_pretty_location structure
-        const event = {
-            id: row.id, // Changed from row.event_id to row.id
-            inserted_at: row.inserted_at,
-            message: row.message,
-            media_url: row.media_url,
-            file_path: row.file_path,
-            latitude: row.latitude,
-            longitude: row.longitude,
-            altitude: row.altitude,
-            heading: row.heading,
-            media_type: row.media_type,
-            device_id: device_id,
-            timestamp_observation: row.timestamp_observation,
-            is_public: row.is_public,
-            earthranger_url: row.earthranger_url,
-            herd_id: row.herd_id,
-            tags: Array.isArray(row.tags) ? row.tags : [],
-            embedded_at: row.embedded_at ?? null,
-            segmented_at: row.segmented_at ?? null,
-            tagged_at: row.tagged_at ?? null,
-        };
-        eventsByDevice[device_id].push(event);
-    });
-    // Add signed URLs to all events
-    const result = {};
-    // Get all file paths for batch URL generation
-    const allFilePaths = [];
-    for (const device_id in eventsByDevice) {
-        const events = eventsByDevice[device_id];
-        events.forEach((event) => {
-            if (isNonEmptyStorageFilePath(event.file_path) &&
-                !allFilePaths.includes(event.file_path)) {
-                allFilePaths.push(event.file_path);
-            }
-        });
-    }
-    // Generate all signed URLs at once
-    const signedUrls = allFilePaths.length > 0
-        ? await generateSignedUrlsBatchWithClient(supabase, allFilePaths, undefined)
-        : [];
-    const urlMap = new Map();
-    allFilePaths.forEach((path, index) => {
-        urlMap.set(path, signedUrls[index]);
-    });
-    // Apply signed URLs to events
-    for (const device_id in eventsByDevice) {
-        const events = eventsByDevice[device_id];
-        const eventsWithSignedUrls = events.map((event) => ({
-            ...event,
-            media_url: isNonEmptyStorageFilePath(event.file_path)
-                ? urlMap.get(event.file_path) ?? null
-                : null,
-        }));
-        result[parseInt(device_id)] = eventsWithSignedUrls;
-    }
-    return IWebResponse.success(result).to_compatible();
+    return get_events_and_tags_for_devices_batch_query(await newServerClient(), device_ids, limit);
 }
 export async function get_event_and_tags_by_event_id(event_id) {
-    const supabase = await newServerClient();
-    // Get event and tags
-    const { data, error } = await supabase
-        .from("events")
-        .select(`
-      *,
-      tags: tags (*)
-    `)
-        .eq("id", event_id);
-    if (error) {
-        console.warn("Error fetching event with tags by event id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    if (!data || data.length === 0) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: "Event not found",
-            data: null,
-        };
-    }
-    // Get herd_id from device
-    const { data: deviceData, error: deviceError } = await supabase
-        .from("devices")
-        .select("herd_id")
-        .eq("id", data[0].device_id)
-        .single();
-    if (deviceError) {
-        console.warn("Error fetching device herd_id:", deviceError.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: deviceError.message,
-            data: null,
-        };
-    }
-    // Transform location to latitude/longitude with better error handling
-    let latitude = null;
-    let longitude = null;
-    try {
-        if (data[0].location) {
-            if (typeof data[0].location === "object" && data[0].location !== null) {
-                // Handle PostGIS Point format: { coordinates: [lon, lat] }
-                if ("coordinates" in data[0].location &&
-                    Array.isArray(data[0].location.coordinates)) {
-                    longitude = data[0].location.coordinates[0];
-                    latitude = data[0].location.coordinates[1];
-                }
-                // Handle alternative format: { x: lon, y: lat }
-                else if ("x" in data[0].location && "y" in data[0].location) {
-                    longitude = data[0].location.x;
-                    latitude = data[0].location.y;
-                }
-            }
-            // Handle string format: "Point(lon lat)"
-            else if (typeof data[0].location === "string") {
-                const match = data[0].location.match(/Point\(([^)]+)\)/);
-                if (match) {
-                    const coords = match[1].split(" ").map(Number);
-                    if (coords.length === 2) {
-                        longitude = coords[0];
-                        latitude = coords[1];
-                    }
-                }
-            }
-        }
-    }
-    catch (locationError) {
-        console.warn("Error parsing location data:", locationError);
-        // Continue with null coordinates
-    }
-    const transformedData = {
-        id: data[0].id,
-        inserted_at: data[0].inserted_at,
-        message: data[0].message,
-        media_url: data[0].media_url,
-        latitude: latitude,
-        longitude: longitude,
-        altitude: data[0].altitude,
-        heading: data[0].heading,
-        media_type: data[0].media_type,
-        device_id: data[0].device_id,
-        timestamp_observation: data[0].timestamp_observation,
-        is_public: data[0].is_public,
-        herd_id: deviceData.herd_id,
-        tags: (data[0].tags || []).map((tag) => {
-            const originLoc = tag.origin_location;
-            const subjectLoc = tag.subject_location;
-            const originLat = originLoc ? extractLatitude(originLoc) : null;
-            const originLon = originLoc ? extractLongitude(originLoc) : null;
-            const subjectLat = subjectLoc ? extractLatitude(subjectLoc) : null;
-            const subjectLon = subjectLoc ? extractLongitude(subjectLoc) : null;
-            return {
-                id: tag.id,
-                inserted_at: tag.inserted_at,
-                artifact_id: tag.artifact_id,
-                event_id: tag.event_id,
-                model_id: tag.model_id,
-                width: tag.width,
-                height: tag.height,
-                conf: tag.conf,
-                x: tag.x,
-                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,
-                origin_roll: tag.origin_roll,
-                sensor_pitch: tag.sensor_pitch,
-                sensor_yaw: tag.sensor_yaw,
-                sensor_roll: tag.sensor_roll,
-                origin_height: tag.origin_height,
-                subject_location: tag.subject_location ?? null,
-                subject_height: tag.subject_height,
-                origin_latitude: originLat,
-                origin_longitude: originLon,
-                subject_latitude: subjectLat,
-                subject_longitude: subjectLon,
-                subject_id: tag.subject_id ?? null,
-            };
-        }),
-        earthranger_url: data[0].earthranger_url,
-        file_path: data[0].file_path,
-        embedded_at: data[0].embedded_at ?? null,
-        segmented_at: data[0].segmented_at ?? null,
-        tagged_at: data[0].tagged_at ?? null,
-    };
-    // Generate signed URL for event
-    let eventWithSignedUrl = transformedData;
-    if (isNonEmptyStorageFilePath(transformedData.file_path)) {
-        const signedUrl = await generateSignedUrlWithClient(supabase, transformedData.file_path, undefined);
-        eventWithSignedUrl = {
-            ...transformedData,
-            media_url: signedUrl,
-        };
-    }
-    return IWebResponse.success(eventWithSignedUrl).to_compatible();
+    return get_event_and_tags_by_event_id_query(await newServerClient(), event_id);
 }
 /** Tags for an artifact with optional timestamp range, model_ids filter, and max_elements (omit or null for no limit). */
 export async function server_get_tags_for_artifact(artifactId, options) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_tags_for_artifact", {
-        artifact_id_caller: artifactId,
-        ...(options?.start_timestamp != null && {
-            start_timestamp_caller: options.start_timestamp,
-        }),
-        ...(options?.end_timestamp != null && {
-            end_timestamp_caller: options.end_timestamp,
-        }),
-        ...rpcModelIdsParam(options?.model_ids),
-        ...(options?.max_elements != null && {
-            max_elements_caller: options.max_elements,
-        }),
-    });
-    if (error) {
-        console.warn("Error fetching tags for artifact:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_tags_for_artifact_query(await newServerClient(), artifactId, options);
 }
 /** Tags for an artifact filtered by frame_index range and minimum confidence. Omit maxElements (or pass null) for no row limit. */
 export async function server_get_tags_for_artifact_by_frame_index(artifactId, minConf, frameIndexStart, frameIndexEnd, model_ids = null, maxElements = null) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_tags_for_artifact_by_frame_index", {
-        artifact_id_caller: artifactId,
-        min_conf_caller: minConf,
-        frame_index_start_caller: frameIndexStart,
-        frame_index_end_caller: frameIndexEnd,
-        ...rpcModelIdsParam(model_ids),
-        ...(maxElements != null && { max_elements_caller: maxElements }),
-    });
-    if (error) {
-        console.warn("Error fetching tags for artifact by frame index:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_tags_for_artifact_by_frame_index_query(await newServerClient(), artifactId, minConf, frameIndexStart, frameIndexEnd, model_ids, maxElements);
 }
 /** Tags for an artifact and subject_id. Omit maxElements (or pass null) for no row limit. */
 export async function server_get_tags_for_artifact_by_subject_id(artifactId, subjectId, model_ids = null, maxElements = null) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_tags_for_artifact_by_subject_id", {
-        artifact_id_caller: artifactId,
-        subject_id_caller: subjectId,
-        ...rpcModelIdsParam(model_ids),
-        ...(maxElements != null && { max_elements_caller: maxElements }),
-    });
-    if (error) {
-        console.warn("Error fetching tags for artifact by subject id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_tags_for_artifact_by_subject_id_query(await newServerClient(), artifactId, subjectId, model_ids, maxElements);
 }
 /** Per-subject aggregates for tags on an artifact (rows with subject_id only). Optional min_avg_conf / min_count / model_ids; max_elements caps subject rows (omit or null for no cap). */
 export async function server_get_minimal_subjects_for_artifact(artifactId, options) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_minimal_subjects_for_artifact", {
-        artifact_id_caller: artifactId,
-        ...(options?.min_avg_conf != null && {
-            min_avg_conf_caller: options.min_avg_conf,
-        }),
-        ...(options?.min_count != null && {
-            min_count_caller: options.min_count,
-        }),
-        ...rpcModelIdsParam(options?.model_ids),
-        ...(options?.max_elements != null && {
-            max_elements_caller: options.max_elements,
-        }),
-    });
-    if (error) {
-        console.warn("Error fetching minimal subjects for artifact:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_minimal_subjects_for_artifact_query(await newServerClient(), artifactId, options);
 }
 /** Tags for an event with optional timestamp range, model_ids filter, and max_elements (omit or null for no limit). */
 export async function server_get_tags_for_event(eventId, options) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_tags_for_event", {
-        event_id_caller: eventId,
-        ...(options?.start_timestamp != null && {
-            start_timestamp_caller: options.start_timestamp,
-        }),
-        ...(options?.end_timestamp != null && {
-            end_timestamp_caller: options.end_timestamp,
-        }),
-        ...rpcModelIdsParam(options?.model_ids),
-        ...(options?.max_elements != null && {
-            max_elements_caller: options.max_elements,
-        }),
-    });
-    if (error) {
-        console.warn("Error fetching tags for event:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_tags_for_event_query(await newServerClient(), eventId, options);
 }

package/dist/helpers/tags.queries.d.ts

@@ -0,0 +1,33 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IEventAndTagsPrettyLocation, IMinimalSubjectForArtifact, ITag, ITagPrettyLocation } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function create_tags_query(client: SupabaseClient<Database>, tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
+export declare function delete_tags_by_ids_query(client: SupabaseClient<Database>, tag_ids: number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function update_tags_query(client: SupabaseClient<Database>, tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
+export declare function get_more_events_with_tags_by_herd_query(client: SupabaseClient<Database>, herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
+export declare function get_events_and_tags_for_device_query(client: SupabaseClient<Database>, device_id: number, limit?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
+export declare function get_events_and_tags_for_devices_batch_query(client: SupabaseClient<Database>, device_ids: number[], limit?: number): Promise<IWebResponseCompatible<{
+    [device_id: number]: IEventAndTagsPrettyLocation[];
+}>>;
+export declare function get_event_and_tags_by_event_id_query(client: SupabaseClient<Database>, event_id: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation>>;
+export declare function get_tags_for_artifact_query(client: SupabaseClient<Database>, artifactId: number, options?: {
+    start_timestamp?: string | null;
+    end_timestamp?: string | null;
+    max_elements?: number | null;
+    model_ids?: number[] | null;
+}): Promise<IWebResponseCompatible<ITagPrettyLocation[]>>;
+export declare function get_tags_for_artifact_by_frame_index_query(client: SupabaseClient<Database>, artifactId: number, minConf: number, frameIndexStart: number, frameIndexEnd: number, model_ids?: number[] | null, maxElements?: number | null): Promise<IWebResponseCompatible<ITagPrettyLocation[]>>;
+export declare function get_tags_for_artifact_by_subject_id_query(client: SupabaseClient<Database>, artifactId: number, subjectId: number, model_ids?: number[] | null, maxElements?: number | null): Promise<IWebResponseCompatible<ITagPrettyLocation[]>>;
+export declare function get_minimal_subjects_for_artifact_query(client: SupabaseClient<Database>, artifactId: number, options?: {
+    min_avg_conf?: number | null;
+    min_count?: number | null;
+    model_ids?: number[] | null;
+    max_elements?: number | null;
+}): Promise<IWebResponseCompatible<IMinimalSubjectForArtifact[]>>;
+export declare function get_tags_for_event_query(client: SupabaseClient<Database>, eventId: number, options?: {
+    start_timestamp?: string | null;
+    end_timestamp?: string | null;
+    max_elements?: number | null;
+    model_ids?: number[] | null;
+}): Promise<IWebResponseCompatible<ITagPrettyLocation[]>>;