@adventurelabs/scout-core 1.5.0 → 1.5.1

package/dist/hooks/useScoutRealtimePins.js

@@ -1,73 +1,7 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback, useState } from "react";
-import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimePins(scoutSupabase) {
-    const channels = useRef([]);
-    const [latestPinUpdate, setLatestPinUpdate] = useState(null);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimePins(scoutSupabase, options) {
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Pin broadcast handler - just pass data, don't mutate state
-    const handlePinBroadcast = useCallback((payload) => {
-        console.log("[Pins] Broadcast received:", payload.payload.operation);
-        const data = payload.payload;
-        const pinData = data.record || data.old_record;
-        if (!pinData)
-            return;
-        let operation;
-        switch (data.operation) {
-            case "INSERT":
-                operation = EnumRealtimeOperation.INSERT;
-                console.log("[Pins] New pin received:", data.record);
-                break;
-            case "UPDATE":
-                operation = EnumRealtimeOperation.UPDATE;
-                console.log("[Pins] Pin updated:", data.record);
-                break;
-            case "DELETE":
-                operation = EnumRealtimeOperation.DELETE;
-                console.log("[Pins] Pin deleted:", data.old_record);
-                break;
-            default:
-                return;
-        }
-        const realtimeData = {
-            data: pinData,
-            operation,
-        };
-        console.log(`[scout-core realtime] PIN ${data.operation} received for pin "${pinData.name}" (${pinData.id}):`, JSON.stringify(realtimeData));
-        setLatestPinUpdate(realtimeData);
-    }, []);
-    // Clear latest update
-    const clearLatestUpdate = useCallback(() => {
-        setLatestPinUpdate(null);
-    }, []);
-    const cleanupChannels = () => {
-        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
-        channels.current = [];
-    };
-    const createPinsChannel = (herdId) => {
-        return scoutSupabase
-            .channel(`${herdId}-pins`, { config: { private: true } })
-            .on("broadcast", { event: "*" }, handlePinBroadcast)
-            .subscribe((status) => {
-            if (status === "SUBSCRIBED") {
-                console.log(`[Pins] ✅ Connected to herd ${herdId} pins broadcasts`);
-            }
-            else if (status === "CHANNEL_ERROR") {
-                console.warn(`[Pins] 🟡 Failed to connect to herd ${herdId} pins broadcasts`);
-            }
-        });
-    };
-    useEffect(() => {
-        cleanupChannels();
-        // Clear previous update when switching herds
-        clearLatestUpdate();
-        // Create pins channel for active herd
-        if (activeHerdId) {
-            const channel = createPinsChannel(activeHerdId);
-            channels.current.push(channel);
-        }
-        return cleanupChannels;
-    }, [activeHerdId, clearLatestUpdate]);
-    return [latestPinUpdate, clearLatestUpdate];
+    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-pins`] : [], options);
 }

package/dist/hooks/useScoutRealtimePlans.d.ts

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IPlan } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimePlans(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IPlan> | null, () => void];
+import { ScoutRealtimeBroadcastOptions } from "./useScoutRealtimeBroadcast";
+export declare function useScoutRealtimePlans(scoutSupabase: SupabaseClient<Database>, options?: ScoutRealtimeBroadcastOptions): [RealtimeData<IPlan> | null, () => void];

package/dist/hooks/useScoutRealtimePlans.js

@@ -1,7 +1,7 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
-export function useScoutRealtimePlans(scoutSupabase) {
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimePlans(scoutSupabase, options) {
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-plans`] : []);
+    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-plans`] : [], options);
 }

package/dist/hooks/useScoutRealtimeSessionIncidents.d.ts

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { ISessionIncident } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeSessionIncidents(scoutSupabase: SupabaseClient<Database>): [RealtimeData<ISessionIncident> | null, () => void];
+import { ScoutRealtimeBroadcastOptions } from "./useScoutRealtimeBroadcast";
+export declare function useScoutRealtimeSessionIncidents(scoutSupabase: SupabaseClient<Database>, options?: ScoutRealtimeBroadcastOptions): [RealtimeData<ISessionIncident> | null, () => void];

package/dist/hooks/useScoutRealtimeSessionIncidents.js

@@ -1,7 +1,7 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
-export function useScoutRealtimeSessionIncidents(scoutSupabase) {
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeSessionIncidents(scoutSupabase, options) {
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-session_incidents`] : []);
+    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-session_incidents`] : [], options);
 }

package/dist/hooks/useScoutRealtimeSessions.d.ts

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { ISessionWithCoordinates } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>): [RealtimeData<ISessionWithCoordinates> | null, () => void];
+import { ScoutRealtimeBroadcastOptions } from "./useScoutRealtimeBroadcast";
+export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>, options?: ScoutRealtimeBroadcastOptions): [RealtimeData<ISessionWithCoordinates> | null, () => void];

package/dist/hooks/useScoutRealtimeSessions.js

@@ -1,73 +1,7 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback, useState } from "react";
-import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimeSessions(scoutSupabase) {
-    const channels = useRef([]);
-    const [latestSessionUpdate, setLatestSessionUpdate] = useState(null);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeSessions(scoutSupabase, options) {
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Session broadcast handler - just pass data, don't mutate state
-    const handleSessionBroadcast = useCallback((payload) => {
-        console.log("[Sessions] Broadcast received:", payload.payload.operation);
-        const data = payload.payload;
-        const sessionData = data.record || data.old_record;
-        if (!sessionData)
-            return;
-        let operation;
-        switch (data.operation) {
-            case "INSERT":
-                operation = EnumRealtimeOperation.INSERT;
-                console.log("[Sessions] New session received:", data.record);
-                break;
-            case "UPDATE":
-                operation = EnumRealtimeOperation.UPDATE;
-                console.log("[Sessions] Session updated:", data.record);
-                break;
-            case "DELETE":
-                operation = EnumRealtimeOperation.DELETE;
-                console.log("[Sessions] Session deleted:", data.old_record);
-                break;
-            default:
-                return;
-        }
-        const realtimeData = {
-            data: sessionData,
-            operation,
-        };
-        console.log(`[scout-core realtime] SESSION ${data.operation} received:`, JSON.stringify(realtimeData));
-        setLatestSessionUpdate(realtimeData);
-    }, []);
-    // Clear latest update
-    const clearLatestUpdate = useCallback(() => {
-        setLatestSessionUpdate(null);
-    }, []);
-    const cleanupChannels = () => {
-        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
-        channels.current = [];
-    };
-    const createSessionsChannel = (herdId) => {
-        return scoutSupabase
-            .channel(`${herdId}-sessions`, { config: { private: true } })
-            .on("broadcast", { event: "*" }, handleSessionBroadcast)
-            .subscribe((status) => {
-            if (status === "SUBSCRIBED") {
-                console.log(`[Sessions] ✅ Connected to herd ${herdId}`);
-            }
-            else if (status === "CHANNEL_ERROR") {
-                console.warn(`[Sessions] 🟡 Failed to connect to herd ${herdId}`);
-            }
-        });
-    };
-    useEffect(() => {
-        cleanupChannels();
-        // Clear previous update when switching herds
-        clearLatestUpdate();
-        // Create sessions channel for active herd
-        if (activeHerdId) {
-            const channel = createSessionsChannel(activeHerdId);
-            channels.current.push(channel);
-        }
-        return cleanupChannels;
-    }, [activeHerdId, clearLatestUpdate]);
-    return [latestSessionUpdate, clearLatestUpdate];
+    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-sessions`] : [], options);
 }

package/dist/hooks/useScoutRealtimeTags.d.ts

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { ITagPrettyLocation } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>): [RealtimeData<ITagPrettyLocation> | null, () => void];
+import { ScoutRealtimeBroadcastOptions } from "./useScoutRealtimeBroadcast";
+export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>, options?: ScoutRealtimeBroadcastOptions): [RealtimeData<ITagPrettyLocation> | null, () => void];

package/dist/hooks/useScoutRealtimeTags.js

@@ -1,73 +1,7 @@
 "use client";
 import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback, useState } from "react";
-import { EnumRealtimeOperation } from "../types/realtime";
-export function useScoutRealtimeTags(scoutSupabase) {
-    const channels = useRef([]);
-    const [latestTagUpdate, setLatestTagUpdate] = useState(null);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeTags(scoutSupabase, options) {
     const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Tag broadcast handler - just pass data, don't mutate state
-    const handleTagBroadcast = useCallback((payload) => {
-        console.log("[Tags] Broadcast received:", payload.payload.operation);
-        const data = payload.payload;
-        const tagData = data.record || data.old_record;
-        if (!tagData)
-            return;
-        let operation;
-        switch (data.operation) {
-            case "INSERT":
-                operation = EnumRealtimeOperation.INSERT;
-                console.log("[Tags] New tag received:", data.record);
-                break;
-            case "UPDATE":
-                operation = EnumRealtimeOperation.UPDATE;
-                console.log("[Tags] Tag updated:", data.record);
-                break;
-            case "DELETE":
-                operation = EnumRealtimeOperation.DELETE;
-                console.log("[Tags] Tag deleted:", data.old_record);
-                break;
-            default:
-                return;
-        }
-        const realtimeData = {
-            data: tagData,
-            operation,
-        };
-        console.log(`[scout-core realtime] TAG ${data.operation} received:`, JSON.stringify(realtimeData));
-        setLatestTagUpdate(realtimeData);
-    }, []);
-    // Clear latest update
-    const clearLatestUpdate = useCallback(() => {
-        setLatestTagUpdate(null);
-    }, []);
-    const cleanupChannels = () => {
-        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
-        channels.current = [];
-    };
-    const createTagsChannel = (herdId) => {
-        return scoutSupabase
-            .channel(`${herdId}-tags`, { config: { private: true } })
-            .on("broadcast", { event: "*" }, handleTagBroadcast)
-            .subscribe((status) => {
-            if (status === "SUBSCRIBED") {
-                console.log(`[Tags] ✅ Connected to herd ${herdId}`);
-            }
-            else if (status === "CHANNEL_ERROR") {
-                console.warn(`[Tags] 🟡 Failed to connect to herd ${herdId}`);
-            }
-        });
-    };
-    useEffect(() => {
-        cleanupChannels();
-        // Clear previous update when switching herds
-        clearLatestUpdate();
-        // Create tags channel for active herd
-        if (activeHerdId) {
-            const channel = createTagsChannel(activeHerdId);
-            channels.current.push(channel);
-        }
-        return cleanupChannels;
-    }, [activeHerdId, clearLatestUpdate]);
-    return [latestTagUpdate, clearLatestUpdate];
+    return useScoutRealtimeBroadcast(scoutSupabase, activeHerdId ? [`${activeHerdId}-tags`] : [], options);
 }

package/dist/hooks/useScoutRealtimeVersionsSoftware.d.ts

@@ -2,4 +2,5 @@ import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IVersionsSoftware } from "../types/db";
 import { RealtimeData } from "../types/realtime";
-export declare function useScoutRealtimeVersionsSoftware(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IVersionsSoftware> | null, () => void];
+import { ScoutRealtimeBroadcastOptions } from "./useScoutRealtimeBroadcast";
+export declare function useScoutRealtimeVersionsSoftware(scoutSupabase: SupabaseClient<Database>, options?: ScoutRealtimeBroadcastOptions): [RealtimeData<IVersionsSoftware> | null, () => void];

package/dist/hooks/useScoutRealtimeVersionsSoftware.js

@@ -1,7 +1,5 @@
 "use client";
-import { useScoutRealtimeBroadcast } from "./useScoutRealtimeBroadcast";
-export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
-    return useScoutRealtimeBroadcast(scoutSupabase, [
-        "versions_software_changes",
-    ]);
+import { useScoutRealtimeBroadcast, } from "./useScoutRealtimeBroadcast";
+export function useScoutRealtimeVersionsSoftware(scoutSupabase, options) {
+    return useScoutRealtimeBroadcast(scoutSupabase, ["versions_software_changes"], options);
 }

package/dist/index.d.ts

@@ -72,6 +72,7 @@ export * from "./helpers/documents";
 export * from "./helpers/maintenance_requests";
 export * from "./helpers/session_incidents";
 export * from "./helpers/contacts";
+export * from "./helpers/operating_contexts";
 export * from "./helpers/lifecycle";
 export * from "./helpers/storagePath";
 export * from "./hooks/useScoutRealtimeBroadcast";
@@ -90,6 +91,7 @@ export * from "./hooks/useScoutRealtimeDocuments";
 export * from "./hooks/useScoutRealtimeMaintenanceRequests";
 export * from "./hooks/useScoutRealtimeContacts";
 export * from "./hooks/useScoutRealtimeSessionIncidents";
+export * from "./hooks/useScoutRealtimeOperatingContexts";
 export * from "./hooks/useScoutRefresh";
 export * from "./hooks/useInfiniteQuery";
 export * from "./providers";

package/dist/index.js

@@ -75,6 +75,7 @@ export * from "./helpers/documents";
 export * from "./helpers/maintenance_requests";
 export * from "./helpers/session_incidents";
 export * from "./helpers/contacts";
+export * from "./helpers/operating_contexts";
 export * from "./helpers/lifecycle";
 export * from "./helpers/storagePath";
 // Hooks
@@ -94,6 +95,7 @@ export * from "./hooks/useScoutRealtimeDocuments";
 export * from "./hooks/useScoutRealtimeMaintenanceRequests";
 export * from "./hooks/useScoutRealtimeContacts";
 export * from "./hooks/useScoutRealtimeSessionIncidents";
+export * from "./hooks/useScoutRealtimeOperatingContexts";
 export * from "./hooks/useScoutRefresh";
 export * from "./hooks/useInfiniteQuery";
 // Providers

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -27,6 +27,7 @@ export interface PubsubTokenMintState {
 }
 export declare function useSupabase(): SupabaseClient<Database>;
 export declare function useClientAbilitiesMint(): ClientAbilitiesMintState;
+export declare function useOptionalClientAbilitiesMint(): ClientAbilitiesMintState | null;
 export declare function usePubsubTokenMint(): PubsubTokenMintState;
 export interface ScoutRefreshProviderProps extends UseScoutRefreshOptions {
     children: ReactNode;

package/dist/providers/ScoutRefreshProvider.js

@@ -32,6 +32,9 @@ export function useSupabase() {
 export function useClientAbilitiesMint() {
     return useScoutRefreshContext().abilities;
 }
+export function useOptionalClientAbilitiesMint() {
+    return useContext(ScoutRefreshContext)?.abilities ?? null;
+}
 export function usePubsubTokenMint() {
     return useScoutRefreshContext().pubsub;
 }

package/dist/types/db.d.ts

@@ -71,6 +71,66 @@ export type IMaintenanceRequest = Database["public"]["Tables"]["maintenance_requ
 export type ISessionIncident = Database["public"]["Tables"]["session_incidents"]["Row"];
 export type SessionIncidentType = Database["public"]["Enums"]["session_incident_type"];
 export type IContact = Database["public"]["Tables"]["contacts"]["Row"];
+export type IDocumentCondition = Database["public"]["Tables"]["document_conditions"]["Row"];
+export type IOperatingContextType = Database["public"]["Tables"]["operating_context_types"]["Row"];
+export type IOperatingContextRole = Database["public"]["Tables"]["operating_context_roles"]["Row"];
+export type IOperatingContextEquipmentCategory = Database["public"]["Tables"]["operating_context_equipment_categories"]["Row"];
+export type IOperatingContextEquipmentItem = Database["public"]["Tables"]["operating_context_equipment_items"]["Row"];
+export type IOperatingContext = Database["public"]["Tables"]["operating_contexts"]["Row"];
+export type IOperatingContextPayload = Database["public"]["Tables"]["operating_context_payloads"]["Row"];
+export type IOperatingContextRoleAssignment = Database["public"]["Tables"]["operating_context_role_assignments"]["Row"];
+export type IOperatingContextEquipmentRequirement = Database["public"]["Tables"]["operating_context_equipment_requirements"]["Row"];
+export type IOperatingContextRegion = Database["public"]["Tables"]["operating_context_regions"]["Row"];
+export type IOperatingContextRisk = Database["public"]["Tables"]["operating_context_risks"]["Row"];
+export type IOperatingContextWeatherSnapshot = Database["public"]["Tables"]["operating_context_weather_snapshots"]["Row"];
+export type OperatingContextPayloadType = Database["public"]["Enums"]["operating_context_payload_type"];
+export type OperatingContextRiskProbability = Database["public"]["Enums"]["operating_context_risk_probability"];
+export type OperatingContextRiskSeverity = Database["public"]["Enums"]["operating_context_risk_severity"];
+export interface OperatingContextListOptions {
+    include_inactive?: boolean;
+    limit?: number;
+    after_id?: number;
+}
+export interface GeographyPoint {
+    type: "Point";
+    coordinates: [number, number];
+}
+export interface GeographyPolygon {
+    type: "Polygon";
+    coordinates: number[][][];
+}
+export interface LifecyclePatch {
+    lifecycle?: EntityLifecycle;
+    lifecycle_reason?: string | null;
+}
+export type DocumentConditionCreateInput = Pick<DocumentConditionInsert, "localization_id" | "condition_text" | "requirement_text">;
+export type DocumentConditionUpdateInput = Partial<DocumentConditionCreateInput> & LifecyclePatch;
+export type OperatingContextTypeCreateInput = Pick<OperatingContextTypeInsert, "localization_id" | "name">;
+export type OperatingContextTypeUpdateInput = Partial<OperatingContextTypeCreateInput> & LifecyclePatch;
+export type OperatingContextRoleCreateInput = Pick<OperatingContextRoleInsert, "localization_id" | "name">;
+export type OperatingContextRoleUpdateInput = Partial<OperatingContextRoleCreateInput> & LifecyclePatch;
+export type OperatingContextEquipmentCategoryCreateInput = Pick<OperatingContextEquipmentCategoryInsert, "localization_id" | "name">;
+export type OperatingContextEquipmentCategoryUpdateInput = Partial<OperatingContextEquipmentCategoryCreateInput> & LifecyclePatch;
+export type OperatingContextEquipmentItemCreateInput = Pick<OperatingContextEquipmentItemInsert, "equipment_category_id" | "name">;
+export type OperatingContextEquipmentItemUpdateInput = Partial<OperatingContextEquipmentItemCreateInput> & LifecyclePatch;
+export type OperatingContextCreateInput = Pick<OperatingContextInsert, "herd_id" | "operating_context_type_id" | "name" | "description" | "valid_from" | "valid_to" | "distance_max_from_home" | "altitude_agl_max" | "involves_third_party_land">;
+export type OperatingContextUpdateInput = Partial<Omit<OperatingContextCreateInput, "herd_id">> & LifecyclePatch;
+export type OperatingContextPayloadCreateInput = Pick<OperatingContextPayloadInsert, "operating_context_id" | "payload_type" | "weight_kg" | "description">;
+export type OperatingContextPayloadUpdateInput = Partial<Omit<OperatingContextPayloadCreateInput, "operating_context_id">> & LifecyclePatch;
+export type OperatingContextRoleAssignmentCreateInput = Pick<OperatingContextRoleAssignmentInsert, "operating_context_id" | "membership_id" | "role_id" | "herd_id">;
+export type OperatingContextRoleAssignmentUpdateInput = Partial<Pick<OperatingContextRoleAssignmentCreateInput, "membership_id" | "role_id">> & LifecyclePatch;
+export type OperatingContextEquipmentRequirementCreateInput = Pick<OperatingContextEquipmentRequirementInsert, "operating_context_id" | "equipment_item_id">;
+export type OperatingContextEquipmentRequirementUpdateInput = Partial<Pick<OperatingContextEquipmentRequirementCreateInput, "equipment_item_id">> & LifecyclePatch;
+export interface OperatingContextRegionCreateInput {
+    operating_context_id: number;
+    is_exclusion: boolean;
+    region: GeographyPolygon | string;
+    name?: string | null;
+    weather_origin?: GeographyPoint | string | null;
+}
+export type OperatingContextRegionUpdateInput = Partial<Omit<OperatingContextRegionCreateInput, "operating_context_id">> & LifecyclePatch;
+export type OperatingContextRiskCreateInput = Pick<OperatingContextRiskInsert, "operating_context_id" | "severity_before" | "probability_before" | "hazard" | "mitigation" | "severity_after" | "probability_after">;
+export type OperatingContextRiskUpdateInput = Partial<Omit<OperatingContextRiskCreateInput, "operating_context_id">> & LifecyclePatch;
 /** A part with its resolved product (parts.product_number -> product_numbers -> products). */
 export type IPartWithProduct = IPart & {
     product?: IProduct | null;
@@ -146,6 +206,28 @@ export type SessionIncidentInsert = Database["public"]["Tables"]["session_incide
 export type SessionIncidentUpdate = Database["public"]["Tables"]["session_incidents"]["Update"];
 export type ContactInsert = Database["public"]["Tables"]["contacts"]["Insert"];
 export type ContactUpdate = Database["public"]["Tables"]["contacts"]["Update"];
+export type DocumentConditionInsert = Database["public"]["Tables"]["document_conditions"]["Insert"];
+export type DocumentConditionUpdate = Database["public"]["Tables"]["document_conditions"]["Update"];
+export type OperatingContextTypeInsert = Database["public"]["Tables"]["operating_context_types"]["Insert"];
+export type OperatingContextTypeUpdate = Database["public"]["Tables"]["operating_context_types"]["Update"];
+export type OperatingContextRoleInsert = Database["public"]["Tables"]["operating_context_roles"]["Insert"];
+export type OperatingContextRoleUpdate = Database["public"]["Tables"]["operating_context_roles"]["Update"];
+export type OperatingContextEquipmentCategoryInsert = Database["public"]["Tables"]["operating_context_equipment_categories"]["Insert"];
+export type OperatingContextEquipmentCategoryUpdate = Database["public"]["Tables"]["operating_context_equipment_categories"]["Update"];
+export type OperatingContextEquipmentItemInsert = Database["public"]["Tables"]["operating_context_equipment_items"]["Insert"];
+export type OperatingContextEquipmentItemUpdate = Database["public"]["Tables"]["operating_context_equipment_items"]["Update"];
+export type OperatingContextInsert = Database["public"]["Tables"]["operating_contexts"]["Insert"];
+export type OperatingContextUpdate = Database["public"]["Tables"]["operating_contexts"]["Update"];
+export type OperatingContextPayloadInsert = Database["public"]["Tables"]["operating_context_payloads"]["Insert"];
+export type OperatingContextPayloadUpdate = Database["public"]["Tables"]["operating_context_payloads"]["Update"];
+export type OperatingContextRoleAssignmentInsert = Database["public"]["Tables"]["operating_context_role_assignments"]["Insert"];
+export type OperatingContextRoleAssignmentUpdate = Database["public"]["Tables"]["operating_context_role_assignments"]["Update"];
+export type OperatingContextEquipmentRequirementInsert = Database["public"]["Tables"]["operating_context_equipment_requirements"]["Insert"];
+export type OperatingContextEquipmentRequirementUpdate = Database["public"]["Tables"]["operating_context_equipment_requirements"]["Update"];
+export type OperatingContextRegionInsert = Database["public"]["Tables"]["operating_context_regions"]["Insert"];
+export type OperatingContextRegionUpdate = Database["public"]["Tables"]["operating_context_regions"]["Update"];
+export type OperatingContextRiskInsert = Database["public"]["Tables"]["operating_context_risks"]["Insert"];
+export type OperatingContextRiskUpdate = Database["public"]["Tables"]["operating_context_risks"]["Update"];
 export interface CredentialQueryArgs {
     type?: string;
 }

package/dist/types/realtime.d.ts

@@ -6,4 +6,5 @@ export declare enum EnumRealtimeOperation {
 export type RealtimeData<T> = {
     data: T;
     operation: EnumRealtimeOperation;
+    table: string;
 };