@adventurelabs/scout-core 1.5.5 → 2.0.1

package/dist/helpers/maintenance_requests_server.d.ts

@@ -0,0 +1,124 @@
+import { MaintenanceRequestInsert, MaintenanceRequestUpdate } from "../types/db";
+export declare function server_get_maintenance_requests_by_device_id(device_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_by_part_id(part_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_by_herd_id(herd_id: number, options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+}[]>>;
+export declare function server_get_maintenance_requests_count_by_herd_id(herd_id: number): Promise<import("../types").IWebResponseCompatible<number>>;
+export declare function server_get_maintenance_request_by_id(request_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_create_maintenance_request(row: MaintenanceRequestInsert): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_update_maintenance_request(request_id: number, patch: MaintenanceRequestUpdate): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;
+export declare function server_delete_maintenance_request(request_id: number): Promise<import("../types").IWebResponseCompatible<{
+    created_at: string;
+    creator_user_id: string | null;
+    defect_timestamp: string;
+    description: string;
+    device_id: number | null;
+    id: number;
+    image: string | null;
+    is_serviceable: boolean;
+    part_id: number | null;
+    remediation_completed_at: string | null;
+    remediation_completed_user_id: string | null;
+    remediation_notes: string | null;
+    session_incident_id: number | null;
+    updated_at: string | null;
+    updated_by_user_id: string | null;
+} | null>>;

package/dist/helpers/maintenance_requests_server.js

@@ -0,0 +1,34 @@
+import { newServerClient } from "../supabase/server";
+import { create_maintenance_request, delete_maintenance_request, get_maintenance_request_by_id, get_maintenance_requests_by_device_id, get_maintenance_requests_by_herd_id, get_maintenance_requests_by_part_id, get_maintenance_requests_count_by_herd_id, update_maintenance_request, } from "./maintenance_requests";
+export async function server_get_maintenance_requests_by_device_id(device_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_device_id(client, device_id);
+}
+export async function server_get_maintenance_requests_by_part_id(part_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_part_id(client, part_id);
+}
+export async function server_get_maintenance_requests_by_herd_id(herd_id, options) {
+    const client = await newServerClient();
+    return get_maintenance_requests_by_herd_id(client, herd_id, options);
+}
+export async function server_get_maintenance_requests_count_by_herd_id(herd_id) {
+    const client = await newServerClient();
+    return get_maintenance_requests_count_by_herd_id(client, herd_id);
+}
+export async function server_get_maintenance_request_by_id(request_id) {
+    const client = await newServerClient();
+    return get_maintenance_request_by_id(client, request_id);
+}
+export async function server_create_maintenance_request(row) {
+    const client = await newServerClient();
+    return create_maintenance_request(client, row);
+}
+export async function server_update_maintenance_request(request_id, patch) {
+    const client = await newServerClient();
+    return update_maintenance_request(client, request_id, patch);
+}
+export async function server_delete_maintenance_request(request_id) {
+    const client = await newServerClient();
+    return delete_maintenance_request(client, request_id);
+}

package/dist/helpers/manufacturers.js

@@ -1,52 +1,14 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { create_manufacturer_query, get_manufacturer_by_id_query, get_manufacturers_query, update_manufacturer_query, } from "./manufacturers.queries";
 export async function server_get_manufacturers(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("manufacturers").select("*").order("name");
-    if (!options?.include_inactive) {
-        query = query.eq("lifecycle", "active");
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_manufacturers_query(await newServerClient(), options);
 }
 export async function server_get_manufacturer_by_id(manufacturer_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .select("*")
-        .eq("id", manufacturer_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_manufacturer_by_id_query(await newServerClient(), manufacturer_id);
 }
 export async function server_create_manufacturer(row) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .insert(row)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_manufacturer_query(await newServerClient(), row);
 }
 export async function server_update_manufacturer(manufacturer_id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("manufacturers")
-        .update(updates)
-        .eq("id", manufacturer_id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_manufacturer_query(await newServerClient(), manufacturer_id, updates);
 }

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

@@ -0,0 +1,10 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IManufacturer, ManufacturerInsert, ManufacturerUpdate } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_manufacturers_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IManufacturer[]>>;
+export declare function get_manufacturer_by_id_query(client: SupabaseClient<Database>, manufacturer_id: number): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function create_manufacturer_query(client: SupabaseClient<Database>, row: ManufacturerInsert): Promise<IWebResponseCompatible<IManufacturer | null>>;
+export declare function update_manufacturer_query(client: SupabaseClient<Database>, manufacturer_id: number, updates: ManufacturerUpdate): Promise<IWebResponseCompatible<IManufacturer | null>>;

package/dist/helpers/manufacturers.queries.js

@@ -0,0 +1,46 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_manufacturers_query(client, options) {
+    let query = client.from("manufacturers").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("lifecycle", "active");
+    }
+    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_manufacturer_by_id_query(client, manufacturer_id) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .select("*")
+        .eq("id", manufacturer_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function create_manufacturer_query(client, row) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .insert(row)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_manufacturer_query(client, manufacturer_id, updates) {
+    const { data, error } = await client
+        .from("manufacturers")
+        .update(updates)
+        .eq("id", manufacturer_id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/media_urls.d.ts

@@ -0,0 +1,13 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { IArtifact, IArtifactWithMediaUrl } from "../types/db";
+import type { Database } from "../types/supabase";
+type EventWithStoragePath = {
+    file_path?: string | null;
+    media_url?: string | null;
+};
+export declare function createSignedUrlMap(client: SupabaseClient<Database>, paths: Iterable<string | null | undefined>): Promise<Map<string, string | null>>;
+export declare function addEventMediaUrls<T extends EventWithStoragePath>(client: SupabaseClient<Database>, events: T[]): Promise<Array<T & {
+    media_url: string | null;
+}>>;
+export declare function addArtifactMediaUrls(client: SupabaseClient<Database>, artifacts: IArtifact[]): Promise<IArtifactWithMediaUrl[]>;
+export {};

package/dist/helpers/media_urls.js

@@ -0,0 +1,21 @@
+import { collectArtifactStoragePaths, withArtifactMediaUrls, } from "./artifactMedia";
+import { generateSignedUrlsBatchWithClient } from "./storage_internal";
+import { isNonEmptyStorageFilePath } from "./storagePath";
+export async function createSignedUrlMap(client, paths) {
+    const uniquePaths = Array.from(new Set(Array.from(paths).filter(isNonEmptyStorageFilePath)));
+    const urls = await generateSignedUrlsBatchWithClient(client, uniquePaths);
+    return new Map(uniquePaths.map((path, index) => [path, urls[index]]));
+}
+export async function addEventMediaUrls(client, events) {
+    const urlMap = await createSignedUrlMap(client, events.map((event) => event.file_path));
+    return events.map((event) => ({
+        ...event,
+        media_url: isNonEmptyStorageFilePath(event.file_path)
+            ? urlMap.get(event.file_path) ?? event.media_url ?? null
+            : event.media_url ?? null,
+    }));
+}
+export async function addArtifactMediaUrls(client, artifacts) {
+    const urlMap = await createSignedUrlMap(client, collectArtifactStoragePaths(artifacts));
+    return artifacts.map((artifact) => withArtifactMediaUrls(artifact, urlMap));
+}

package/dist/helpers/models.js

@@ -1,95 +1,23 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// function that fetches a single model by id; null if not found
+import { create_models_per_jobs_per_herd_query, delete_models_per_jobs_per_herd_by_ids_query, get_model_by_id_query, get_models_by_ids_query, get_models_per_jobs_per_herd_by_herd_query, get_models_query, update_models_per_jobs_per_herd_query, } from "./models.queries";
 export async function server_get_model_by_id(model_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models")
-        .select("*")
-        .eq("id", model_id)
-        .maybeSingle();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return get_model_by_id_query(await newServerClient(), model_id);
 }
-// function that fetches multiple models by id
 export async function server_get_models_by_ids(model_ids) {
-    if (model_ids.length === 0) {
-        return IWebResponse.success([]).to_compatible();
-    }
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models")
-        .select("*")
-        .in("id", model_ids);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_by_ids_query(await newServerClient(), model_ids);
 }
-// function that lists models, active only by default
 export async function server_get_models(options) {
-    const supabase = await newServerClient();
-    let query = supabase.from("models").select("*").order("name");
-    if (!options?.include_inactive) {
-        query = query.eq("is_active", true);
-    }
-    const { data, error } = await query;
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_query(await newServerClient(), options);
 }
-// function that fetches the model activations for a herd
 export async function server_get_models_per_jobs_per_herd_by_herd(herd_id) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .select("*")
-        .eq("herd_id", herd_id);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
-    }
-    return IWebResponse.success(data ?? []).to_compatible();
+    return get_models_per_jobs_per_herd_by_herd_query(await newServerClient(), herd_id);
 }
-// function that creates a model activation
 export async function server_create_models_per_jobs_per_herd(activation) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .insert(activation)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return create_models_per_jobs_per_herd_query(await newServerClient(), activation);
 }
-// function that updates a model activation
 export async function server_update_models_per_jobs_per_herd(id, updates) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .update(updates)
-        .eq("id", id)
-        .select("*")
-        .single();
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
-    }
-    return IWebResponse.success(data).to_compatible();
+    return update_models_per_jobs_per_herd_query(await newServerClient(), id, updates);
 }
-// function that deletes model activations by ids
 export async function server_delete_models_per_jobs_per_herd_by_ids(ids) {
-    const supabase = await newServerClient();
-    const { error } = await supabase
-        .from("models_per_jobs_per_herd")
-        .delete()
-        .in("id", ids);
-    if (error) {
-        return { status: EnumWebResponse.ERROR, msg: error.message, data: false };
-    }
-    return IWebResponse.success(true).to_compatible();
+    return delete_models_per_jobs_per_herd_by_ids_query(await newServerClient(), ids);
 }

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

@@ -0,0 +1,13 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IModel, IModelsPerJobsPerHerd } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_model_by_id_query(client: SupabaseClient<Database>, model_id: number): Promise<IWebResponseCompatible<IModel | null>>;
+export declare function get_models_by_ids_query(client: SupabaseClient<Database>, model_ids: number[]): Promise<IWebResponseCompatible<IModel[]>>;
+export declare function get_models_query(client: SupabaseClient<Database>, options?: {
+    include_inactive?: boolean;
+}): Promise<IWebResponseCompatible<IModel[]>>;
+export declare function get_models_per_jobs_per_herd_by_herd_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd[]>>;
+export declare function create_models_per_jobs_per_herd_query(client: SupabaseClient<Database>, activation: Omit<IModelsPerJobsPerHerd, "id" | "inserted_at">): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd>>;
+export declare function update_models_per_jobs_per_herd_query(client: SupabaseClient<Database>, id: number, updates: Partial<Omit<IModelsPerJobsPerHerd, "id" | "inserted_at">>): Promise<IWebResponseCompatible<IModelsPerJobsPerHerd>>;
+export declare function delete_models_per_jobs_per_herd_by_ids_query(client: SupabaseClient<Database>, ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/models.queries.js

@@ -0,0 +1,79 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_model_by_id_query(client, model_id) {
+    const { data, error } = await client
+        .from("models")
+        .select("*")
+        .eq("id", model_id)
+        .maybeSingle();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_models_by_ids_query(client, model_ids) {
+    if (model_ids.length === 0) {
+        return IWebResponse.success([]).to_compatible();
+    }
+    const { data, error } = await client
+        .from("models")
+        .select("*")
+        .in("id", model_ids);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function get_models_query(client, options) {
+    let query = client.from("models").select("*").order("name");
+    if (!options?.include_inactive) {
+        query = query.eq("is_active", true);
+    }
+    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_models_per_jobs_per_herd_by_herd_query(client, herd_id) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: [] };
+    }
+    return IWebResponse.success(data ?? []).to_compatible();
+}
+export async function create_models_per_jobs_per_herd_query(client, activation) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .insert(activation)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function update_models_per_jobs_per_herd_query(client, id, updates) {
+    const { data, error } = await client
+        .from("models_per_jobs_per_herd")
+        .update(updates)
+        .eq("id", id)
+        .select("*")
+        .single();
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function delete_models_per_jobs_per_herd_by_ids_query(client, ids) {
+    const { error } = await client
+        .from("models_per_jobs_per_herd")
+        .delete()
+        .in("id", ids);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: false };
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/observations_server.d.ts

@@ -0,0 +1,51 @@
+import { ObservationInsert, ObservationUpdate } from "../types/db";
+export declare function server_get_observations_for_session(session_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+}[]>>;
+export declare function server_get_observation_by_id(observation_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_create_observation(row: ObservationInsert): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_update_observation(observation_id: number, patch: ObservationUpdate): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;
+export declare function server_delete_observation(observation_id: number): Promise<import("../types").IWebResponseCompatible<{
+    action_complete: boolean;
+    action_required: string | null;
+    description: string;
+    id: number;
+    inserted_at: string;
+    session_id: number;
+    timestamp: string | null;
+    updated_at: string | null;
+} | null>>;

package/dist/helpers/observations_server.js

@@ -0,0 +1,22 @@
+import { newServerClient } from "../supabase/server";
+import { create_observation, delete_observation, get_observation_by_id, get_observations_for_session, update_observation, } from "./observations";
+export async function server_get_observations_for_session(session_id) {
+    const client = await newServerClient();
+    return get_observations_for_session(client, session_id);
+}
+export async function server_get_observation_by_id(observation_id) {
+    const client = await newServerClient();
+    return get_observation_by_id(client, observation_id);
+}
+export async function server_create_observation(row) {
+    const client = await newServerClient();
+    return create_observation(client, row);
+}
+export async function server_update_observation(observation_id, patch) {
+    const client = await newServerClient();
+    return update_observation(client, observation_id, patch);
+}
+export async function server_delete_observation(observation_id) {
+    const client = await newServerClient();
+    return delete_observation(client, observation_id);
+}