SDKs

npm install @wede/sdk

import { WedeClient } from '@wede/sdk'

const client = new WedeClient({ apiKey: 'wede_live_YOUR_KEY' })

// Send an event
const event = await client.sendEvent({
  type: 'EMERGENCY',
  priority: 'high',
  vertical: 'healthcare',
  idempotency_key: crypto.randomUUID(),
  payload: { condition: 'cardiac_arrest' },
  location: { lat: 38.7169, lng: -9.1395 }
})

// Score and dispatch teams
const scored = await client.scoreTeams({
  lat: 38.7169, lng: -9.1395,
  vertical: 'healthcare', priority: 'high'
})

await client.dispatch({
  event_id: event.data.event_id,
  team_id: scored.data[0].team_id,
  event_lat: 38.7169, event_lng: -9.1395
})

import { WedeClient, WedeCache, WedeOfflineDispatch, WedeDeviceId } from '@wede/sdk'

// Generate permanent device ID on first install
const deviceId = await WedeDeviceId.getOrCreate(storage)
await client.registerDevice(deviceId, 'web', '2.0.0')

// Offline dispatch — uses local score engine, queues if no connectivity
const result = await offline.dispatch('cardiac_arrest', {
  lat: 38.7169, lng: -9.1395,
  vertical: 'healthcare'
})
// result.queued === true when offline

// Sync when connectivity restored
await client.syncDeviceQueue(deviceId)

npm install @wede/react-native-sdk
npm install @react-native-async-storage/async-storage

import AsyncStorage from '@react-native-async-storage/async-storage'
import { WedeClient } from '@wede/react-native-sdk'

const client = new WedeClient({
  apiKey: 'wede_live_YOUR_KEY',
  storage: AsyncStorage,
})

// Works online and offline
const result = await client.dispatch({
  event_id: 'uuid', team_id: 'uuid',
  event_lat: 38.7169, event_lng: -9.1395
})

// Request backup for active mission
await client.requestBackup({
  mission_id: 'uuid', event_id: 'uuid',
  event_lat: 38.7169, event_lng: -9.1395
})

dependencies {
    implementation("pt.wede.sdk:wede-sdk-android:1.2.0")
}

import pt.wede.sdk.core.WedeClient
import pt.wede.sdk.sync.WedeDeviceId

val client = WedeClient(
    apiKey = "wede_live_YOUR_KEY",
    storage = SharedPreferencesStorage(context)
)

// Generate permanent device ID
val deviceId = WedeDeviceId.getOrCreate(storage)
client.registerDevice(deviceId, "android", "2.0.0")

// Dispatch (online or offline)
client.dispatch(eventId = "uuid", teamId = "uuid",
    eventLat = 38.7169, eventLng = -9.1395)

// Request backup
client.requestBackup(
    missionId = "uuid", eventId = "uuid",
    eventLat = 38.7169, eventLng = -9.1395
)

// Sync when back online
client.syncDeviceQueue(deviceId)

dependencies: [
    .package(url: "https://github.com/Wedeadmin/wede-sdk-swift.git", from: "1.2.0")
]

import WedeSDK

let client = WedeClient(apiKey: "wede_live_YOUR_KEY")

// Register device
let deviceId = WedeDeviceId.getOrCreate()
try await client.registerDevice(deviceId: deviceId, platform: "ios", appVersion: "2.0.0")

// Score teams
let scored = try await client.scoreTeams(lat: 38.7169, lng: -9.1395,
    vertical: "healthcare", priority: "high")

// Dispatch
try await client.dispatch(eventId: "uuid", teamId: scored.data[0].teamId,
    eventLat: 38.7169, eventLng: -9.1395)

// Request backup
try await client.requestBackup(missionId: "uuid", eventId: "uuid",
    eventLat: 38.7169, eventLng: -9.1395)

// Sync
try await client.syncDeviceQueue(deviceId: deviceId)

pip install wede-sdk

from wede import WedeClient

client = WedeClient(api_key="wede_live_YOUR_KEY")

# Send event
result = client.send_event(
    type="EMERGENCY", priority="high", vertical="healthcare",
    idempotency_key="evt-001",
    payload={"condition": "cardiac_arrest"},
    location={"lat": 38.7169, "lng": -9.1395}
)

# Score and dispatch
scored = client.score_teams(lat=38.7169, lng=-9.1395, vertical="healthcare")
client.dispatch(event_id=result["event_id"], team_id=scored["data"][0]["team_id"])

# Request backup
client.request_backup(
    mission_id="uuid", event_id="uuid",
    event_lat=38.7169, event_lng=-9.1395
)

# Update dispatch settings
client.update_dispatch_settings(
    dispatch_mode=True,
    dispatch_threshold=0.20,
    reinforcement_timeout_min=10
)