@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/eventUtils.js

@@ -1,16 +1,6 @@
-/**
- * Gets the media URL for an event (signed URL if file_path exists, otherwise media_url)
- * @param event - Event object that may have file_path or media_url
- * @returns string | null - The media URL or null if none available
- */
 export function getEventMediaUrl(event) {
     return event.media_url || null;
 }
-/**
- * Checks if an event has any media URL available
- * @param event - Event object
- * @returns boolean - True if event has any media URL
- */
 export function hasEventMedia(event) {
     return !!(event.media_url || event.file_path);
 }

package/dist/helpers/events.d.ts

@@ -10,7 +10,6 @@ export declare function server_update_event(events: (EventUpdate & {
     id: number;
 })[]): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_delete_event(id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
-/** Semantic search over events using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export declare function server_match_events_by_vertex_embedding(query_embedding: number[], match_threshold: number, match_count: number, options?: {
     herd_id?: number | null;
 }): Promise<IWebResponseCompatible<IEvent[]>>;

package/dist/helpers/events.js

@@ -1,120 +1,20 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { EnumSessionsVisibility } from "../types/events";
-import { generateSignedUrlWithClient } from "./storage_internal";
-import { isNonEmptyStorageFilePath } from "./storagePath";
+import { delete_event_query, get_event_by_id_query, get_total_events_by_herd_query, insert_event_query, match_events_by_vertex_embedding_query, update_event_query, } from "./events.queries";
 export async function server_get_event_by_id(id) {
-    const client = await newServerClient();
-    const { data, error } = await client
-        .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 (isNonEmptyStorageFilePath(event.file_path)) {
-        media_url = await generateSignedUrlWithClient(client, event.file_path);
-    }
-    return IWebResponse.success({
-        ...event,
-        media_url,
-    }).to_compatible();
+    return get_event_by_id_query(await newServerClient(), id);
 }
-// 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();
-    // Convert sessions_visibility to exclude_session_events boolean
-    const exclude_session_events = sessions_visibility === EnumSessionsVisibility.Exclude;
-    const { data, error } = (await supabase.rpc("get_total_events_for_herd_with_session_filter", {
-        herd_id_caller: herd_id,
-        exclude_session_events: exclude_session_events,
-    }));
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: 0,
-        };
-    }
-    else {
-        return IWebResponse.success(data || 0).to_compatible();
-    }
+    return get_total_events_by_herd_query(await newServerClient(), herd_id, sessions_visibility);
 }
-// Insert new events (accepts array for batch operations)
 export async function server_insert_event(events) {
-    const client = await newServerClient();
-    const eventsArray = Array.isArray(events) ? events : [events];
-    const { data, error } = await client
-        .from("events")
-        .insert(eventsArray)
-        .select("*");
-    if (error) {
-        console.warn("Error inserting events:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
+    return insert_event_query(await newServerClient(), events);
 }
-// Update existing events (accepts array for batch operations)
-// Each event in the array must include an 'id' field
 export async function server_update_event(events) {
-    const client = await newServerClient();
-    const eventsArray = Array.isArray(events) ? events : [events];
-    const updatedEvents = [];
-    for (const event of eventsArray) {
-        const { id, ...updateData } = event;
-        delete updateData.inserted_at;
-        const { data, error } = await client
-            .from("events")
-            .update(updateData)
-            .eq("id", id)
-            .select("*")
-            .single();
-        if (error) {
-            console.warn("Error updating event:", error.message);
-            return {
-                status: EnumWebResponse.ERROR,
-                msg: error.message,
-                data: [],
-            };
-        }
-        if (data) {
-            updatedEvents.push(data);
-        }
-    }
-    return IWebResponse.success(updatedEvents).to_compatible();
+    return update_event_query(await newServerClient(), events);
 }
 export async function server_delete_event(id) {
-    const client = await newServerClient();
-    const ids = Array.isArray(id) ? id : [id];
-    const { error } = await client.from("events").delete().in("id", ids);
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(true).to_compatible();
+    return delete_event_query(await newServerClient(), id);
 }
-/** Semantic search over events using Vertex multimodal embedding (embedding_vertex_mm_01). */
 export async function server_match_events_by_vertex_embedding(query_embedding, match_threshold, match_count, options) {
-    const client = await newServerClient();
-    const rpcName = "match_events_by_vertex_embedding";
-    const { data, error } = await client.rpc(rpcName, {
-        query_embedding: JSON.stringify(query_embedding),
-        match_threshold,
-        match_count,
-        herd_id_caller: options?.herd_id ?? undefined,
-    });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success((data ?? [])).to_compatible();
+    return match_events_by_vertex_embedding_query(await newServerClient(), query_embedding, match_threshold, match_count, options);
 }

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

@@ -0,0 +1,17 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { EventInsert, EventUpdate, IEvent, IEventWithMediaUrl } from "../types/db";
+import { EnumSessionsVisibility } from "../types/events";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_event_by_id_query(client: SupabaseClient<Database>, id: number): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
+export declare function get_total_events_by_herd_query(client: SupabaseClient<Database>, herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
+export declare function insert_event_query(client: SupabaseClient<Database>, events: EventInsert | EventInsert[]): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function update_event_query(client: SupabaseClient<Database>, events: (EventUpdate & {
+    id: number;
+}) | (EventUpdate & {
+    id: number;
+})[]): Promise<IWebResponseCompatible<IEvent[]>>;
+export declare function delete_event_query(client: SupabaseClient<Database>, id: number | number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function match_events_by_vertex_embedding_query(client: SupabaseClient<Database>, query_embedding: number[], match_threshold: number, match_count: number, options?: {
+    herd_id?: number | null;
+}): Promise<IWebResponseCompatible<IEvent[]>>;

package/dist/helpers/{events.internal.js → events.queries.js}

@@ -1,7 +1,7 @@
+import { EnumSessionsVisibility } from "../types/events";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { generateSignedUrlWithClient } from "./storage_internal";
-import { isNonEmptyStorageFilePath } from "./storagePath";
-export async function getEventByIdWithClient(client, id) {
+import { addEventMediaUrls } from "./media_urls";
+export async function get_event_by_id_query(client, id) {
     const { data, error } = await client
         .from("events")
         .select("*")
@@ -14,16 +14,25 @@ export async function getEventByIdWithClient(client, id) {
         return IWebResponse.success(null).to_compatible();
     }
     const event = data;
-    let media_url = null;
-    if (isNonEmptyStorageFilePath(event.file_path)) {
-        media_url = await generateSignedUrlWithClient(client, event.file_path);
+    const [eventWithUrl] = await addEventMediaUrls(client, [event]);
+    return IWebResponse.success(eventWithUrl).to_compatible();
+}
+export async function get_total_events_by_herd_query(client, herd_id, sessions_visibility) {
+    const exclude_session_events = sessions_visibility === EnumSessionsVisibility.Exclude;
+    const { data, error } = (await client.rpc("get_total_events_for_herd_with_session_filter", {
+        herd_id_caller: herd_id,
+        exclude_session_events,
+    }));
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: 0,
+        };
     }
-    return IWebResponse.success({
-        ...event,
-        media_url,
-    }).to_compatible();
+    return IWebResponse.success(data || 0).to_compatible();
 }
-export async function insertEventWithClient(client, events) {
+export async function insert_event_query(client, events) {
     const eventsArray = Array.isArray(events) ? events : [events];
     const { data, error } = await client
         .from("events")
@@ -39,7 +48,7 @@ export async function insertEventWithClient(client, events) {
     }
     return IWebResponse.success(data || []).to_compatible();
 }
-export async function updateEventWithClient(client, events) {
+export async function update_event_query(client, events) {
     const eventsArray = Array.isArray(events) ? events : [events];
     const updatedEvents = [];
     for (const event of eventsArray) {
@@ -65,7 +74,7 @@ export async function updateEventWithClient(client, events) {
     }
     return IWebResponse.success(updatedEvents).to_compatible();
 }
-export async function deleteEventWithClient(client, id) {
+export async function delete_event_query(client, id) {
     const ids = Array.isArray(id) ? id : [id];
     const { error } = await client.from("events").delete().in("id", ids);
     if (error) {
@@ -73,13 +82,13 @@ export async function deleteEventWithClient(client, id) {
     }
     return IWebResponse.success(true).to_compatible();
 }
-export async function matchEventsByVertexEmbeddingWithClient(client, query_embedding, match_threshold, match_count, herd_id) {
+export async function match_events_by_vertex_embedding_query(client, query_embedding, match_threshold, match_count, options) {
     const rpcName = "match_events_by_vertex_embedding";
     const { data, error } = await client.rpc(rpcName, {
         query_embedding: JSON.stringify(query_embedding),
         match_threshold,
         match_count,
-        herd_id_caller: herd_id ?? undefined,
+        herd_id_caller: options?.herd_id ?? undefined,
     });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();

package/dist/helpers/health_metrics.js

@@ -1,43 +1,8 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { get_health_metrics_query, get_health_metrics_summary_query, } from "./health_metrics.queries";
 export async function server_get_health_metrics(device_id, options) {
-    const supabase = await newServerClient();
-    const lookbackMs = options.lookbackSeconds * 1000;
-    const anchorMs = options.timestampAnchor != null && options.timestampAnchor !== ""
-        ? new Date(options.timestampAnchor).getTime()
-        : Date.now();
-    const startMs = anchorMs - lookbackMs;
-    const startISO = new Date(startMs).toISOString();
-    const endISO = new Date(anchorMs).toISOString();
-    let query = supabase
-        .from("health_metrics")
-        .select("*")
-        .eq("device_id", device_id)
-        .gte("timestamp", startISO)
-        .lt("timestamp", endISO)
-        .order("timestamp", { ascending: false })
-        .limit(options.maxCount);
-    if (options.source != null && options.source !== "") {
-        query = query.eq("source", options.source);
-    }
-    if (options.metricName != null && options.metricName !== "") {
-        query = query.eq("metric_name", options.metricName);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_health_metrics_query(await newServerClient(), device_id, options);
 }
 export async function server_get_health_metrics_summary(device_id, lookbackMinutes = 60) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_health_metrics_summary", {
-        p_device_id: device_id,
-        p_lookback_minutes: lookbackMinutes,
-    });
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_health_metrics_summary_query(await newServerClient(), device_id, lookbackMinutes);
 }

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

@@ -0,0 +1,12 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHealthMetric, IHealthMetricSummaryRow } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_health_metrics_query(client: SupabaseClient<Database>, device_id: number, options: {
+    lookbackSeconds: number;
+    maxCount: number;
+    timestampAnchor?: string | null;
+    source?: string | null;
+    metricName?: string | null;
+}): Promise<IWebResponseCompatible<IHealthMetric[]>>;
+export declare function get_health_metrics_summary_query(client: SupabaseClient<Database>, device_id: number, lookbackMinutes?: number): Promise<IWebResponseCompatible<IHealthMetricSummaryRow[]>>;

package/dist/helpers/health_metrics.queries.js

@@ -0,0 +1,39 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_health_metrics_query(client, device_id, options) {
+    const lookbackMs = options.lookbackSeconds * 1000;
+    const anchorMs = options.timestampAnchor != null && options.timestampAnchor !== ""
+        ? new Date(options.timestampAnchor).getTime()
+        : Date.now();
+    const startMs = anchorMs - lookbackMs;
+    const startISO = new Date(startMs).toISOString();
+    const endISO = new Date(anchorMs).toISOString();
+    let query = client
+        .from("health_metrics")
+        .select("*")
+        .eq("device_id", device_id)
+        .gte("timestamp", startISO)
+        .lt("timestamp", endISO)
+        .order("timestamp", { ascending: false })
+        .limit(options.maxCount);
+    if (options.source != null && options.source !== "") {
+        query = query.eq("source", options.source);
+    }
+    if (options.metricName != null && options.metricName !== "") {
+        query = query.eq("metric_name", options.metricName);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_health_metrics_summary_query(client, device_id, lookbackMinutes = 60) {
+    const { data, error } = await client.rpc("get_health_metrics_summary", {
+        p_device_id: device_id,
+        p_lookback_minutes: lookbackMinutes,
+    });
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}

package/dist/helpers/heartbeats.js

@@ -1,90 +1,11 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Function to get the last heartbeat for a device
+import { check_device_online_status_query, get_heartbeats_by_device_query, get_last_heartbeat_by_device_query, } from "./heartbeats.queries";
 export async function server_get_last_heartbeat_by_device(device_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false })
-        .limit(1)
-        .single();
-    if (error) {
-        // If no heartbeats found, return null data instead of error
-        if (error.code === "PGRST116") {
-            return {
-                status: EnumWebResponse.SUCCESS,
-                msg: null,
-                data: null,
-            };
-        }
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(data).to_compatible();
-    }
+    return get_last_heartbeat_by_device_query(await newServerClient(), device_id);
 }
-// Function to get all heartbeats for a device
 export async function server_get_heartbeats_by_device(device_id, limit) {
-    const supabase = await newServerClient();
-    let query = supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false });
-    if (limit) {
-        query = query.limit(limit);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    else {
-        return IWebResponse.success(data || []).to_compatible();
-    }
+    return get_heartbeats_by_device_query(await newServerClient(), device_id, limit);
 }
-// Function to check if a device is online based on heartbeat recency
 export async function server_check_device_online_status(device_id, offline_threshold_minutes = 5) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("heartbeats")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("timestamp", { ascending: false })
-        .limit(1)
-        .single();
-    if (error) {
-        // If no heartbeats found
-        if (error.code === "PGRST116") {
-            return IWebResponse.success({
-                is_online: false,
-                last_heartbeat: null,
-                minutes_since_last_heartbeat: null,
-            }).to_compatible();
-        }
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    const now = new Date();
-    const heartbeatTime = new Date(data.timestamp);
-    const minutesSinceLastHeartbeat = Math.floor((now.getTime() - heartbeatTime.getTime()) / (1000 * 60));
-    const isOnline = minutesSinceLastHeartbeat <= offline_threshold_minutes;
-    return IWebResponse.success({
-        is_online: isOnline,
-        last_heartbeat: data,
-        minutes_since_last_heartbeat: minutesSinceLastHeartbeat,
-    }).to_compatible();
+    return check_device_online_status_query(await newServerClient(), device_id, offline_threshold_minutes);
 }

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

@@ -0,0 +1,11 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IHeartbeat } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_last_heartbeat_by_device_query(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IHeartbeat | null>>;
+export declare function get_heartbeats_by_device_query(client: SupabaseClient<Database>, device_id: number, limit?: number): Promise<IWebResponseCompatible<IHeartbeat[]>>;
+export declare function check_device_online_status_query(client: SupabaseClient<Database>, device_id: number, offline_threshold_minutes?: number): Promise<IWebResponseCompatible<{
+    is_online: boolean;
+    last_heartbeat: IHeartbeat | null;
+    minutes_since_last_heartbeat: number | null;
+}>>;

package/dist/helpers/heartbeats.queries.js

@@ -0,0 +1,76 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_last_heartbeat_by_device_query(client, device_id) {
+    const { data, error } = await client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        if (error.code === "PGRST116") {
+            return {
+                status: EnumWebResponse.SUCCESS,
+                msg: null,
+                data: null,
+            };
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_heartbeats_by_device_query(client, device_id, limit) {
+    let query = client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false });
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data || []).to_compatible();
+}
+export async function check_device_online_status_query(client, device_id, offline_threshold_minutes = 5) {
+    const { data, error } = await client
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        if (error.code === "PGRST116") {
+            return IWebResponse.success({
+                is_online: false,
+                last_heartbeat: null,
+                minutes_since_last_heartbeat: null,
+            }).to_compatible();
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    const now = new Date();
+    const heartbeatTime = new Date(data.timestamp);
+    const minutesSinceLastHeartbeat = Math.floor((now.getTime() - heartbeatTime.getTime()) / (1000 * 60));
+    const isOnline = minutesSinceLastHeartbeat <= offline_threshold_minutes;
+    return IWebResponse.success({
+        is_online: isOnline,
+        last_heartbeat: data,
+        minutes_since_last_heartbeat: minutesSinceLastHeartbeat,
+    }).to_compatible();
+}

package/dist/helpers/herd_allowed_domains.js

@@ -1,15 +1,5 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
+import { get_herd_allowed_domains_query } from "./herd_allowed_domains.queries";
 export async function server_get_herd_allowed_domains(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("herd_allowed_domains")
-        .select("*")
-        .eq("herd_id", herd_id)
-        .order("domain", { ascending: true });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_herd_allowed_domains_query(await newServerClient(), herd_id);
 }

package/dist/helpers/{herd_allowed_domains_internal.d.ts → herd_allowed_domains.queries.d.ts}

@@ -2,4 +2,4 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { IHerdAllowedDomain } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { Database } from "../types/supabase";
-export declare function getHerdAllowedDomainsWithClient(supabase: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;
+export declare function get_herd_allowed_domains_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IHerdAllowedDomain[]>>;

package/dist/helpers/{herd_allowed_domains_internal.js → herd_allowed_domains.queries.js}

@@ -1,6 +1,6 @@
 import { IWebResponse } from "../types/requests";
-export async function getHerdAllowedDomainsWithClient(supabase, herd_id) {
-    const { data, error } = await supabase
+export async function get_herd_allowed_domains_query(client, herd_id) {
+    const { data, error } = await client
         .from("herd_allowed_domains")
         .select("*")
         .eq("herd_id", herd_id)

package/dist/helpers/herd_credentials_server.d.ts

@@ -0,0 +1,76 @@
+import { CredentialQueryArgs, HerdCredentialInsert, HerdCredentialUpdate } from "../types/db";
+export declare function server_get_herd_credentials_by_herd_id(herd_id: number, args?: CredentialQueryArgs): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+}[]>>;
+export declare function server_get_herd_credential_by_id(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+} | null>>;
+export declare function server_create_herd_credential(row: HerdCredentialInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+} | null>>;
+export declare function server_update_herd_credential(credential_id: number, patch: HerdCredentialUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+} | null>>;
+export declare function server_delete_herd_credential(credential_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    expiration: string | null;
+    file_uri: string | null;
+    herd_id: number;
+    id: number;
+    issuer: string;
+    lifecycle: import("../types").Database["public"]["Enums"]["entity_lifecycle"];
+    lifecycle_changed_at: string;
+    lifecycle_changed_by: string | null;
+    lifecycle_reason: string | null;
+    tracking_number: string | null;
+    type: string;
+    updated_at: string;
+} | null>>;