@adventurelabs/scout-core 2.0.0 → 2.0.2

package/dist/helpers/cache.js

@@ -1,52 +1,114 @@
-const DB_NAME = "ScoutCache";
-const DB_VERSION = 8;
+const LEGACY_DB_NAME = "ScoutCache";
+const DB_VERSION = 9;
 const HERD_MODULES_STORE = "herd_modules";
 const JWT_MINTS_STORE = "jwt_mints";
 const CACHE_METADATA_STORE = "cache_metadata";
-// Default TTL: 24 hours (1 day)
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+let legacyDbDeleteStarted = false;
+function getSupabaseProjectRef() {
+    const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    if (!url) {
+        throw new Error("Missing NEXT_PUBLIC_SUPABASE_URL");
+    }
+    const ref = new URL(url).hostname.split(".")[0];
+    if (!ref) {
+        throw new Error("Supabase URL has no project ref");
+    }
+    return ref;
+}
+function buildDbName(userId) {
+    return `ScoutCache_${getSupabaseProjectRef()}_${userId}`;
+}
+function deleteLegacyDatabase() {
+    if (legacyDbDeleteStarted || typeof indexedDB === "undefined")
+        return;
+    legacyDbDeleteStarted = true;
+    indexedDB.deleteDatabase(LEGACY_DB_NAME);
+}
+function transactionComplete(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+        transaction.onabort = () => reject(transaction.error);
+    });
+}
 export class ScoutCache {
     constructor() {
-        this.db = null;
-        this.initPromise = null;
+        this.dbName = null;
+        this.userId = null;
+        this.databases = new Map();
+        this.initPromises = new Map();
+        this.deletePromises = new Map();
         this.stats = {
             hits: 0,
             misses: 0,
         };
     }
-    async init() {
-        if (this.db)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = new Promise((resolve, reject) => {
-            const request = indexedDB.open(DB_NAME, DB_VERSION);
+    async setScope(userId) {
+        if (!userId) {
+            throw new Error("ScoutCache.setScope requires a user id");
+        }
+        const nextName = buildDbName(userId);
+        if (this.dbName !== nextName) {
+            this.stats = { hits: 0, misses: 0 };
+        }
+        this.dbName = nextName;
+        this.userId = userId;
+        deleteLegacyDatabase();
+        await this.getDatabase(userId);
+    }
+    getScopeUserId() {
+        return this.userId;
+    }
+    async getDatabase(userId) {
+        const dbName = userId ? buildDbName(userId) : this.dbName;
+        if (!dbName) {
+            throw new Error("ScoutCache scope not set — call setScope(userId) first");
+        }
+        const db = await this.init(dbName);
+        if (!this.validateDatabaseSchema(db)) {
+            throw new Error("ScoutCache database schema is invalid");
+        }
+        return db;
+    }
+    async init(dbName) {
+        const deleting = this.deletePromises.get(dbName);
+        if (deleting) {
+            await deleting;
+        }
+        const database = this.databases.get(dbName);
+        if (database)
+            return database;
+        const pending = this.initPromises.get(dbName);
+        if (pending)
+            return pending;
+        const initPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(dbName, DB_VERSION);
             request.onerror = () => {
                 console.error("[ScoutCache] Failed to open IndexedDB:", request.error);
-                this.db = null;
-                this.initPromise = null;
                 reject(request.error);
             };
             request.onsuccess = () => {
-                this.db = request.result;
-                console.log("[ScoutCache] IndexedDB initialized successfully");
-                // Add error handler for runtime database errors
-                this.db.onerror = (event) => {
+                const openedDatabase = request.result;
+                this.databases.set(dbName, openedDatabase);
+                openedDatabase.onerror = (event) => {
                     console.error("[ScoutCache] Database error:", event);
                 };
-                resolve();
+                openedDatabase.onversionchange = () => {
+                    openedDatabase.close();
+                    if (this.databases.get(dbName) === openedDatabase) {
+                        this.databases.delete(dbName);
+                    }
+                };
+                resolve(openedDatabase);
             };
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
                 try {
-                    console.log(`[ScoutCache] Upgrading database to version ${DB_VERSION}`);
-                    // Remove all existing object stores to ensure clean slate
                     const existingStores = Array.from(db.objectStoreNames);
                     for (const storeName of existingStores) {
-                        console.log(`[ScoutCache] Removing existing object store: ${storeName}`);
                         db.deleteObjectStore(storeName);
                     }
-                    // Create herd modules store (unified storage for all herd data)
                     const herdModulesStore = db.createObjectStore(HERD_MODULES_STORE, {
                         keyPath: "herdId",
                     });
@@ -56,20 +118,15 @@ export class ScoutCache {
                     herdModulesStore.createIndex("dbVersion", "dbVersion", {
                         unique: false,
                     });
-                    console.log("[ScoutCache] Created herd_modules object store");
                     const jwtMintsStore = db.createObjectStore(JWT_MINTS_STORE, {
                         keyPath: "key",
                     });
                     jwtMintsStore.createIndex("timestamp", "timestamp", {
                         unique: false,
                     });
-                    console.log("[ScoutCache] Created jwt_mints object store");
-                    // Create cache metadata store
-                    const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
+                    db.createObjectStore(CACHE_METADATA_STORE, {
                         keyPath: "key",
                     });
-                    console.log("[ScoutCache] Created cache_metadata object store");
-                    console.log(`[ScoutCache] Database schema upgrade to version ${DB_VERSION} completed`);
                 }
                 catch (error) {
                     console.error("[ScoutCache] Error during database upgrade:", error);
@@ -80,78 +137,59 @@ export class ScoutCache {
                 console.warn("[ScoutCache] Database upgrade blocked - other connections may need to be closed");
             };
         });
-        return this.initPromise;
-    }
-    validateDatabaseSchema() {
-        if (!this.db)
-            return false;
-        const hasHerdModulesStore = this.db.objectStoreNames.contains(HERD_MODULES_STORE);
-        const hasJwtMintsStore = this.db.objectStoreNames.contains(JWT_MINTS_STORE);
-        const hasMetadataStore = this.db.objectStoreNames.contains(CACHE_METADATA_STORE);
-        if (!hasHerdModulesStore) {
-            console.error("[ScoutCache] Missing herd_modules object store");
-        }
-        if (!hasJwtMintsStore) {
-            console.error("[ScoutCache] Missing jwt_mints object store");
+        this.initPromises.set(dbName, initPromise);
+        try {
+            return await initPromise;
         }
-        if (!hasMetadataStore) {
-            console.error("[ScoutCache] Missing cache_metadata object store");
+        finally {
+            if (this.initPromises.get(dbName) === initPromise) {
+                this.initPromises.delete(dbName);
+            }
         }
-        return hasHerdModulesStore && hasJwtMintsStore && hasMetadataStore;
     }
-    async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
-            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            const timestamp = Date.now();
-            const version = "2.0.0";
-            // Store each herd module (contains all nested data - devices, events, zones, etc.)
-            herdModules.forEach((herdModule) => {
-                if (herdModule.herd.id == null)
-                    return;
-                const cacheEntry = {
-                    herdId: herdModule.herd.id.toString(),
-                    data: herdModule,
-                    timestamp,
-                    dbVersion: DB_VERSION,
-                };
-                herdModulesStore.put(cacheEntry);
-            });
-            // Store cache metadata
-            const metadata = {
-                key: "herd_modules",
+    validateDatabaseSchema(db) {
+        return (db.objectStoreNames.contains(HERD_MODULES_STORE) &&
+            db.objectStoreNames.contains(JWT_MINTS_STORE) &&
+            db.objectStoreNames.contains(CACHE_METADATA_STORE));
+    }
+    async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag, userId) {
+        const db = await this.getDatabase(userId);
+        const transaction = db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
+        const completion = transactionComplete(transaction);
+        const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
+        const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+        const timestamp = Date.now();
+        herdModulesStore.clear();
+        herdModules.forEach((herdModule) => {
+            if (herdModule.herd.id == null)
+                return;
+            herdModulesStore.put({
+                herdId: herdModule.herd.id.toString(),
+                data: herdModule,
                 timestamp,
-                ttl: ttlMs,
-                version,
                 dbVersion: DB_VERSION,
-                etag,
-                lastModified: timestamp,
-            };
-            metadataStore.put(metadata);
+            });
         });
+        const metadata = {
+            key: "herd_modules",
+            timestamp,
+            ttl: ttlMs,
+            version: "2.0.0",
+            dbVersion: DB_VERSION,
+            etag,
+            lastModified: timestamp,
+        };
+        metadataStore.put(metadata);
+        await completion;
     }
-    async getHerdModules() {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readonly");
+    async getHerdModules(userId) {
+        const scopedUserId = userId ?? this.userId ?? undefined;
+        const db = await this.getDatabase(scopedUserId);
+        const transaction = db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readonly");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            // Get metadata first
             const metadataRequest = metadataStore.get("herd_modules");
             metadataRequest.onsuccess = () => {
                 const metadata = metadataRequest.result;
@@ -161,12 +199,10 @@ export class ScoutCache {
                     resolve({ data: null, isStale: true, age: 0, metadata: null });
                     return;
                 }
-                // Check if cache is from an incompatible DB version
                 if (!metadata.dbVersion || metadata.dbVersion !== DB_VERSION) {
                     console.log(`[ScoutCache] Cache from incompatible DB version (${metadata.dbVersion || "unknown"} !== ${DB_VERSION}), invalidating`);
                     this.stats.misses++;
-                    // Clear old cache asynchronously
-                    this.clearHerdModules().catch((error) => {
+                    this.clearHerdModules(scopedUserId).catch((error) => {
                         console.warn("[ScoutCache] Failed to clear old cache:", error);
                     });
                     resolve({ data: null, isStale: true, age: 0, metadata: null });
@@ -174,18 +210,16 @@ export class ScoutCache {
                 }
                 const age = now - metadata.timestamp;
                 const isStale = age > metadata.ttl;
-                // Get all herd modules
                 const getAllRequest = herdModulesStore.getAll();
                 getAllRequest.onsuccess = () => {
                     const cacheEntries = getAllRequest.result;
                     const herdModules = cacheEntries
                         .filter((entry) => entry.data &&
                         entry.data.herd &&
-                        entry.data.herd.slug &&
+                        entry.data.herd.id != null &&
                         entry.dbVersion === DB_VERSION)
                         .map((entry) => entry.data)
                         .sort((a, b) => (a.herd?.slug || "").localeCompare(b.herd?.slug || ""));
-                    // Update stats
                     if (herdModules.length > 0) {
                         this.stats.hits++;
                     }
@@ -202,33 +236,21 @@ export class ScoutCache {
             };
         });
     }
-    async setJwtMint(key, mint) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([JWT_MINTS_STORE], "readwrite");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            transaction.objectStore(JWT_MINTS_STORE).put({
-                key,
-                data: mint,
-                timestamp: Date.now(),
-                dbVersion: DB_VERSION,
-            });
+    async setJwtMint(key, mint, userId) {
+        const db = await this.getDatabase(userId);
+        const transaction = db.transaction([JWT_MINTS_STORE], "readwrite");
+        const completion = transactionComplete(transaction);
+        transaction.objectStore(JWT_MINTS_STORE).put({
+            key,
+            data: mint,
+            timestamp: Date.now(),
+            dbVersion: DB_VERSION,
         });
+        await completion;
     }
-    async getJwtMint(key) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([JWT_MINTS_STORE], "readonly");
+    async getJwtMint(key, userId) {
+        const db = await this.getDatabase(userId);
+        const transaction = db.transaction([JWT_MINTS_STORE], "readonly");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
             const request = transaction.objectStore(JWT_MINTS_STORE).get(key);
@@ -260,58 +282,32 @@ export class ScoutCache {
             };
         });
     }
-    async clearJwtMint(key) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([JWT_MINTS_STORE], "readwrite");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            transaction.objectStore(JWT_MINTS_STORE).delete(key);
-        });
+    async clearJwtMint(key, userId) {
+        if (!userId && !this.dbName)
+            return;
+        const db = await this.getDatabase(userId);
+        const transaction = db.transaction([JWT_MINTS_STORE], "readwrite");
+        const completion = transactionComplete(transaction);
+        transaction.objectStore(JWT_MINTS_STORE).delete(key);
+        await completion;
     }
-    async clearHerdModules() {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
-            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            herdModulesStore.clear();
-            metadataStore.delete("herd_modules");
-        });
+    async clearHerdModules(userId) {
+        if (!userId && !this.dbName)
+            return;
+        const db = await this.getDatabase(userId);
+        const transaction = db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
+        const completion = transactionComplete(transaction);
+        transaction.objectStore(HERD_MODULES_STORE).clear();
+        transaction.objectStore(CACHE_METADATA_STORE).delete("herd_modules");
+        await completion;
     }
-    async invalidateHerdModules() {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        if (!this.validateDatabaseSchema()) {
-            throw new Error("Database schema validation failed - required object stores not found");
-        }
-        const transaction = this.db.transaction([CACHE_METADATA_STORE], "readwrite");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            metadataStore.delete("herd_modules");
-            metadataStore.delete("providers");
-        });
+    async invalidateHerdModules(userId) {
+        await this.clearHerdModules(userId);
     }
-    async getCacheStats() {
-        const result = await this.getHerdModules();
+    async getCacheStats(userId) {
+        const result = await this.getHerdModules(userId);
         const totalRequests = this.stats.hits + this.stats.misses;
         const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
-        // Calculate size based on herd modules count (no longer including events/sessions/artifacts arrays)
         const size = result.data?.length || 0;
         return {
             size,
@@ -322,26 +318,25 @@ export class ScoutCache {
             totalMisses: this.stats.misses,
         };
     }
-    async isCacheValid(ttlMs) {
-        const result = await this.getHerdModules();
+    async isCacheValid(ttlMs, userId) {
+        const result = await this.getHerdModules(userId);
         if (!result.data || !result.metadata)
             return false;
         const effectiveTtl = ttlMs || result.metadata.ttl;
         return !result.isStale && result.age < effectiveTtl;
     }
-    async getCacheAge() {
-        const result = await this.getHerdModules();
+    async getCacheAge(userId) {
+        const result = await this.getHerdModules(userId);
         return result.age;
     }
-    async shouldRefresh(maxAgeMs, forceRefresh) {
+    async shouldRefresh(maxAgeMs, forceRefresh, userId) {
         if (forceRefresh) {
             return { shouldRefresh: true, reason: "Force refresh requested" };
         }
-        const result = await this.getHerdModules();
+        const result = await this.getHerdModules(userId);
         if (!result.data || result.data.length === 0) {
             return { shouldRefresh: true, reason: "No cached data" };
         }
-        // Check for DB version mismatch
         if (!result.metadata ||
             !result.metadata.dbVersion ||
             result.metadata.dbVersion !== DB_VERSION) {
@@ -361,12 +356,12 @@ export class ScoutCache {
         }
         return { shouldRefresh: false, reason: "Cache is valid and fresh" };
     }
-    async preloadCache(loadFunction, ttlMs = DEFAULT_TTL_MS) {
+    async preloadCache(loadFunction, ttlMs = DEFAULT_TTL_MS, userId) {
         try {
             console.log("[ScoutCache] Starting background cache preload...");
             const startTime = Date.now();
             const herdModules = await loadFunction();
-            await this.setHerdModules(herdModules, ttlMs);
+            await this.setHerdModules(herdModules, ttlMs, undefined, userId);
             const duration = Date.now() - startTime;
             console.log(`[ScoutCache] Background preload completed in ${duration}ms`);
         }
@@ -380,66 +375,62 @@ export class ScoutCache {
     getCurrentDbVersion() {
         return DB_VERSION;
     }
-    async isCacheVersionCompatible() {
+    async isCacheVersionCompatible(userId) {
         try {
-            const result = await this.getHerdModules();
+            const result = await this.getHerdModules(userId);
             if (!result.metadata)
                 return false;
-            return (result.metadata.dbVersion !== undefined &&
-                result.metadata.dbVersion === DB_VERSION);
+            return result.metadata.dbVersion === DB_VERSION;
         }
         catch (error) {
             console.warn("[ScoutCache] Version compatibility check failed:", error);
             return false;
         }
     }
-    async resetDatabase() {
-        console.log("[ScoutCache] Resetting database...");
-        // Close existing connection
-        if (this.db) {
-            this.db.close();
-            this.db = null;
+    async resetDatabase(userId) {
+        const dbName = userId ? buildDbName(userId) : this.dbName;
+        if (!dbName) {
+            return;
+        }
+        const existingDelete = this.deletePromises.get(dbName);
+        if (existingDelete)
+            return existingDelete;
+        const deletePromise = (async () => {
+            const pendingDatabase = this.initPromises.get(dbName);
+            const database = this.databases.get(dbName) ??
+                (pendingDatabase ? await pendingDatabase : null);
+            database?.close();
+            this.databases.delete(dbName);
+            this.initPromises.delete(dbName);
+            await new Promise((resolve, reject) => {
+                const request = indexedDB.deleteDatabase(dbName);
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+                request.onblocked = () => {
+                    console.warn("[ScoutCache] Database reset blocked - close all other tabs");
+                };
+            });
+        })();
+        this.deletePromises.set(dbName, deletePromise);
+        try {
+            await deletePromise;
+        }
+        finally {
+            if (this.deletePromises.get(dbName) === deletePromise) {
+                this.deletePromises.delete(dbName);
+            }
         }
-        this.initPromise = null;
-        // Delete the database
-        return new Promise((resolve, reject) => {
-            const deleteRequest = indexedDB.deleteDatabase(DB_NAME);
-            deleteRequest.onsuccess = () => {
-                console.log("[ScoutCache] Database reset successfully");
-                resolve();
-            };
-            deleteRequest.onerror = () => {
-                console.error("[ScoutCache] Failed to reset database:", deleteRequest.error);
-                reject(deleteRequest.error);
-            };
-            deleteRequest.onblocked = () => {
-                console.warn("[ScoutCache] Database reset blocked - close all other tabs");
-                // Continue anyway, it will resolve when unblocked
-            };
-        });
     }
-    async checkDatabaseHealth() {
+    async checkDatabaseHealth(userId) {
         const issues = [];
         try {
-            await this.init();
-            if (!this.db) {
-                issues.push("Database connection not established");
-                return { healthy: false, issues };
-            }
-            if (!this.validateDatabaseSchema()) {
-                issues.push("Database schema validation failed");
-            }
-            // Check version compatibility
-            const isVersionCompatible = await this.isCacheVersionCompatible();
+            await this.getDatabase(userId);
+            const isVersionCompatible = await this.isCacheVersionCompatible(userId);
             if (!isVersionCompatible) {
                 issues.push(`Cache version incompatible (current: ${DB_VERSION})`);
             }
-            // Try a simple read operation
             try {
-                const result = await this.getHerdModules();
-                if (result.data === null && result.age === 0) {
-                    // This is expected for empty cache, not an error
-                }
+                await this.getHerdModules(userId);
             }
             catch (error) {
                 issues.push(`Read operation failed: ${error}`);
@@ -453,6 +444,19 @@ export class ScoutCache {
             issues,
         };
     }
+    async clearAll(userId) {
+        deleteLegacyDatabase();
+        const userToClear = userId ?? this.userId;
+        if (!userToClear)
+            return;
+        await this.resetDatabase(userToClear);
+        if (this.userId === userToClear) {
+            this.userId = null;
+            this.dbName = null;
+        }
+    }
 }
-// Singleton instance
 export const scoutCache = new ScoutCache();
+export async function clearScoutClientState(userId) {
+    await scoutCache.clearAll(userId);
+}

package/dist/helpers/compliance.d.ts

@@ -0,0 +1,26 @@
+import type { ComplianceResourceCreateInput, ComplianceResourceTypeCreateInput, ComplianceResourceTypeUpdateInput, ComplianceResourceUpdateInput, ContactTypeCreateInput, ContactTypeUpdateInput, HerdOperatingPermissionCreateInput, HerdOperatingPermissionUpdateInput, IComplianceResource, IComplianceResourceType, IContactType, IHerdOperatingPermission, IOperatingContextContact, IOperatingContextPointOfInterest, IOperatingContextPointOfInterestType, IOperatingPermission, OperatingContextContactCreateInput, OperatingContextContactUpdateInput, OperatingContextListOptions, OperatingContextPointOfInterestCreateInput, OperatingContextPointOfInterestTypeCreateInput, OperatingContextPointOfInterestTypeUpdateInput, OperatingContextPointOfInterestUpdateInput, OperatingPermissionCreateInput, OperatingPermissionUpdateInput } from "../types/db";
+import type { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_contact_types_by_localization(localizationId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IContactType[]>>;
+export declare function server_create_contact_type(row: ContactTypeCreateInput): Promise<IWebResponseCompatible<IContactType | null>>;
+export declare function server_update_contact_type(id: number, updates: ContactTypeUpdateInput): Promise<IWebResponseCompatible<IContactType | null>>;
+export declare function server_get_operating_context_point_of_interest_types_by_localization(localizationId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextPointOfInterestType[]>>;
+export declare function server_create_operating_context_point_of_interest_type(row: OperatingContextPointOfInterestTypeCreateInput): Promise<IWebResponseCompatible<IOperatingContextPointOfInterestType | null>>;
+export declare function server_update_operating_context_point_of_interest_type(id: number, updates: OperatingContextPointOfInterestTypeUpdateInput): Promise<IWebResponseCompatible<IOperatingContextPointOfInterestType | null>>;
+export declare function server_get_operating_permissions_by_localization(localizationId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingPermission[]>>;
+export declare function server_create_operating_permission(row: OperatingPermissionCreateInput): Promise<IWebResponseCompatible<IOperatingPermission | null>>;
+export declare function server_update_operating_permission(id: number, updates: OperatingPermissionUpdateInput): Promise<IWebResponseCompatible<IOperatingPermission | null>>;
+export declare function server_get_compliance_resource_types(options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IComplianceResourceType[]>>;
+export declare function server_create_compliance_resource_type(row: ComplianceResourceTypeCreateInput): Promise<IWebResponseCompatible<IComplianceResourceType | null>>;
+export declare function server_update_compliance_resource_type(id: number, updates: ComplianceResourceTypeUpdateInput): Promise<IWebResponseCompatible<IComplianceResourceType | null>>;
+export declare function server_get_compliance_resources_by_localization(localizationId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IComplianceResource[]>>;
+export declare function server_create_compliance_resource(row: ComplianceResourceCreateInput): Promise<IWebResponseCompatible<IComplianceResource | null>>;
+export declare function server_update_compliance_resource(id: number, updates: ComplianceResourceUpdateInput): Promise<IWebResponseCompatible<IComplianceResource | null>>;
+export declare function server_get_operating_context_points_of_interest_by_operating_context(operatingContextId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextPointOfInterest[]>>;
+export declare function server_create_operating_context_point_of_interest(row: OperatingContextPointOfInterestCreateInput): Promise<IWebResponseCompatible<IOperatingContextPointOfInterest | null>>;
+export declare function server_update_operating_context_point_of_interest(id: number, updates: OperatingContextPointOfInterestUpdateInput): Promise<IWebResponseCompatible<IOperatingContextPointOfInterest | null>>;
+export declare function server_get_operating_context_contacts_by_operating_context(operatingContextId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IOperatingContextContact[]>>;
+export declare function server_create_operating_context_contact(row: OperatingContextContactCreateInput): Promise<IWebResponseCompatible<IOperatingContextContact | null>>;
+export declare function server_update_operating_context_contact(id: number, updates: OperatingContextContactUpdateInput): Promise<IWebResponseCompatible<IOperatingContextContact | null>>;
+export declare function server_get_herd_operating_permissions_by_herd(herdId: number, options?: OperatingContextListOptions): Promise<IWebResponseCompatible<IHerdOperatingPermission[]>>;
+export declare function server_create_herd_operating_permission(row: HerdOperatingPermissionCreateInput): Promise<IWebResponseCompatible<IHerdOperatingPermission | null>>;
+export declare function server_update_herd_operating_permission(id: number, updates: HerdOperatingPermissionUpdateInput): Promise<IWebResponseCompatible<IHerdOperatingPermission | null>>;