@wedetech/sdk 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wede tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# @wedetech/sdk
+
+Official JavaScript and TypeScript client for the wede API.
+
+wede keeps critical operations running whatever the state of the network. Operations captured without connectivity are synchronised when it returns, and each one is stored exactly once.
+
+Full documentation: [docs.wede.pt](https://docs.wede.pt)
+
+## Requirements
+
+Node.js 20 or later, browsers, Cloudflare Workers and Pages Functions, Deno, Bun and React Native.
+
+## Installation
+
+```bash
+npm install @wedetech/sdk
+```
+
+## Credentials
+
+There are two ways to authenticate. Use the one that matches where the code runs.
+
+**On a server**, use the tenant API key (`wede_live_...` or `wede_test_...`). Keep it as a secret and never ship it in a browser or mobile bundle.
+
+```typescript
+import { WedeClient } from '@wedetech/sdk'
+
+const wede = new WedeClient({ apiKey: process.env.WEDE_API_KEY! })
+```
+
+**On a device or in a browser**, sign the user in and use the session token. What the token can do depends on the user's role in your tenant.
+
+```typescript
+const { token } = await WedeClient.login(email, password)
+const wede = new WedeClient({ accessToken: token })
+```
+
+The token expires after 8 hours. Sign in again and call `wede.setAccessToken(newToken)`. Five failed sign-in attempts lock the account for 15 minutes.
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `apiKey` | | Tenant API key, server side only |
+| `accessToken` | | User session token |
+| `baseUrl` | `https://api.wede.pt` | API base URL |
+| `timeout` | `10000` | Request timeout in milliseconds |
+| `retries` | `3` | Attempts on network failure |
+
+## Send an event
+
+```typescript
+const res = await wede.sendEvent({
+  type: 'cardiac_arrest',
+  vertical: 'healthcare',
+  priority: 'high',
+  payload: { patient_ref: 'P-1042' },
+  metadata: { zone_id: 'LIS-01' },
+})
+
+res.event_id
+```
+
+| Field | Required | Values |
+| --- | --- | --- |
+| `type` | yes | An event type of your catalog for this vertical, or an event category (see below) |
+| `vertical` | yes | A vertical registered for your tenant |
+| `priority` | yes | `low`, `normal`, `high`, `critical` |
+| `idempotency_key` | no | Unique per operation. Generated when omitted |
+| `payload` | yes | Your operation data |
+| `metadata` | no | `zone_id`, `operator_id`, `sdk_version`, `offline_generated_at`, `connectivity_state_at_generation` |
+| `destination` | no | One-off recipient for this event: `phone`, `email` or `device_id`. Never stored |
+
+Sending the same `idempotency_key` twice returns `409 duplicate_event`, so retries are always safe.
+
+## Event types and categories
+
+Event types are yours. You create them in your catalog, per vertical, and link each one to a category:
+
+```typescript
+await wede.createCatalogAction({
+  vertical: 'healthcare',
+  code: 'cardiac_arrest',
+  name: 'Cardiac arrest',
+  category: 'EMERGENCY',
+})
+```
+
+Categories are a shared list kept by wede (`listEventCategories()`), for example `EMERGENCY`, `PAYMENT`, `BOOKING`, `STATUS_UPDATE`, `IDENTITY_CONFIRM`, `DISPATCH` and `OTHER`. The list stays open and grows over time. Using them is optional: an event can use a category code directly as its `type`.
+
+An event's `type` is accepted when it is an active type of your catalog for the event's vertical, or an active category. Anything else returns `422 unknown_event_type`. Every event stores its category at the moment it is received; changing a type's category later only affects new events.
+
+
+## Operations captured without connectivity
+
+Capture each operation at the moment it happens and keep the returned object in your own storage. When connectivity returns, send them in one batch.
+
+```typescript
+import { captureEvent } from '@wedetech/sdk'
+
+const captured = await captureEvent({
+  type: 'delivery_confirmed',
+  vertical: 'logistics',
+  priority: 'normal',
+  payload: { parcel: 'PX-2231' },
+})
+// store `captured` locally, unchanged
+
+const result = await wede.syncBatch(queuedEvents)
+result.summary   // { total, accepted, duplicates, rejected }
+result.results   // one entry per event
+```
+
+- Up to 500 events per call.
+- `captureEvent` adds the capture time and an integrity checksum. An event whose content changes after capture is rejected.
+- `duplicates` is your proof against double counting: an operation that already reached wede, online or in an earlier batch, is stored only once.
+- Each event is checked on its own: an event with an unknown type or vertical, or a checksum that does not match, is rejected and the others are still accepted.
+
+The same captured object can be sent online first with `sendEvent`. If the connection drops before you get the answer, keep it in the queue and send it in the batch.
+
+## React Native
+
+The package works in React Native as is. When the runtime has no Web Crypto, the SDK uses its own SHA-256 implementation, so no polyfill is needed. Use `accessToken`, never an API key, inside the app.
+
+## Errors
+
+| Class | When |
+| --- | --- |
+| `WedeAuthError` | Missing or invalid credentials (`401`) |
+| `WedeError` | The API answered with an error. `status`, `code` and `details` carry the reason |
+| `WedeNetworkError` | No response after all retries |
+
+Common codes: `duplicate_event` (409), `unknown_event_type` (422), `unknown_vertical` (422), `invalid_payload` (422), `forbidden` (403).
+
+## Method reference
+
+| Area | Methods |
+| --- | --- |
+| Sign in | `WedeClient.login`, `setAccessToken` |
+| Events | `sendEvent`, `listEvents`, `getEvent` |
+| Event types | `listEventCategories`, `listCatalogActions`, `createCatalogAction`, `updateCatalogAction`, `deleteCatalogAction` |
+| Offline sync | `captureEvent`, `syncBatch`, `getSyncStatus`, `registerDevice`, `syncDeviceQueue` |
+| Connectivity | `getConnectivityStatus`, `reportConnectivity`, `listZones`, `getZone` |
+| Tenant | `getTenantInfo`, `getUsage`, `getBilling`, `updateDispatchSettings` |
+| Teams and dispatch | `listTeams`, `getTeam`, `updateMemberLocation`, `scoreTeams`, `dispatch`, `dispatchAction` |
+| Missions | `listMissions`, `listMyMissions`, `getMission`, `updateMissionStatus` |
+| Parsers | `listParsers`, `getParser`, `getActiveParser` |
+| Webhooks | `listWebhooks`, `createWebhook`, `deleteWebhook` |
+
+What each credential can call depends on its role in your tenant. A call outside it returns `403`.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,92 @@
+import type { WedeClientOptions, EventInput, SendEventResult, EventList, EventDetail, ListEventsParams, CapturedEvent, SyncBatchResult, SyncStatus, ConnectivityState, RegisterDeviceParams, SyncDeviceQueueParams, SyncDeviceQueueResult, ConnectivityStatus, ConnectivityReport, Zone, ZoneList, TenantInfo, Usage, Billing, DispatchSettings, Team, TeamList, ScoreTeamsParams, ScoreTeamsResult, DispatchParams, DispatchActionParams, Mission, MissionList, ListMissionsParams, MissionStatus, CatalogAction, CreateCatalogAction, UpdateCatalogAction, EventCategory, LoginResult, Parser, ParserList, Webhook, CreateWebhook } from './types.js';
+export declare const SDK_VERSION = "2.0.0";
+/**
+ * Integrity checksum expected by POST /v1/sync/batch:
+ * SHA-256 (hex) of JSON.stringify(payload) + idempotency_key + offline_generated_at.
+ */
+export declare function integrityHash(payload: Record<string, unknown>, idempotencyKey: string, offlineGeneratedAt: string): Promise<string>;
+/**
+ * Captures an event at the moment it happens, without connectivity.
+ * Store the returned object as is; do not change the payload afterwards.
+ */
+export declare function captureEvent(event: EventInput, connectivityState?: ConnectivityState): Promise<CapturedEvent>;
+export declare class WedeClient {
+    private readonly apiKey?;
+    private accessToken?;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly retries;
+    constructor(options: WedeClientOptions);
+    /**
+     * Signs a user in and returns a session token for WedeClient({ accessToken }).
+     * Five failed attempts lock the account for 15 minutes.
+     */
+    static login(email: string, password: string, options?: {
+        baseUrl?: string;
+        timeout?: number;
+    }): Promise<LoginResult>;
+    /** Replaces the session token, for example after signing in again. */
+    setAccessToken(token: string): void;
+    private authHeader;
+    private request;
+    private qs;
+    /** Submits an event. Same idempotency_key twice returns 409 duplicate_event. */
+    sendEvent(event: EventInput): Promise<SendEventResult>;
+    listEvents(params?: ListEventsParams): Promise<EventList>;
+    getEvent(eventId: string): Promise<EventDetail>;
+    /** Sends events captured with captureEvent(). Up to 500 per call. */
+    syncBatch(events: CapturedEvent[]): Promise<SyncBatchResult>;
+    getSyncStatus(): Promise<SyncStatus>;
+    registerDevice(params: RegisterDeviceParams): Promise<{
+        device_id: string;
+        registered: boolean;
+    }>;
+    syncDeviceQueue(params: SyncDeviceQueueParams): Promise<SyncDeviceQueueResult>;
+    getConnectivityStatus(zoneId?: string): Promise<ConnectivityStatus>;
+    reportConnectivity(report: ConnectivityReport): Promise<void>;
+    listZones(): Promise<ZoneList>;
+    getZone(zoneCode: string): Promise<Zone>;
+    getTenantInfo(): Promise<TenantInfo>;
+    /** from and to are ISO 8601 dates. */
+    getUsage(from: string, to: string): Promise<Usage>;
+    getBilling(): Promise<Billing>;
+    updateDispatchSettings(settings: Partial<DispatchSettings>): Promise<DispatchSettings>;
+    listTeams(): Promise<TeamList>;
+    getTeam(teamId: string): Promise<Team>;
+    updateMemberLocation(teamId: string, memberId: string, lat: number, lng: number): Promise<{
+        id: string;
+        lat: number;
+        lng: number;
+        last_seen: string;
+    }>;
+    /** Free teams ranked by best conditions (score 0 to 1, higher is better). */
+    scoreTeams(params: ScoreTeamsParams): Promise<ScoreTeamsResult>;
+    /** Dispatches a specific team to an event. */
+    dispatch(params: DispatchParams): Promise<Record<string, unknown>>;
+    /** Scores and, if automatic dispatch is on, dispatches for a catalog action. */
+    dispatchAction(params: DispatchActionParams): Promise<Record<string, unknown>>;
+    listMissions(params?: ListMissionsParams): Promise<MissionList>;
+    /** Missions assigned to the authenticated field user. */
+    listMyMissions(): Promise<MissionList>;
+    getMission(missionId: string): Promise<Mission>;
+    updateMissionStatus(missionId: string, status: MissionStatus, feedback?: Record<string, unknown>): Promise<Mission>;
+    /** The open list of event categories kept by wede. */
+    listEventCategories(): Promise<{
+        data: EventCategory[];
+        count: number;
+    }>;
+    listCatalogActions(vertical?: string): Promise<{
+        data: CatalogAction[];
+    }>;
+    createCatalogAction(action: CreateCatalogAction): Promise<CatalogAction>;
+    updateCatalogAction(actionId: string, changes: UpdateCatalogAction): Promise<CatalogAction>;
+    deleteCatalogAction(actionId: string): Promise<void>;
+    listParsers(): Promise<ParserList>;
+    getParser(parserId: string): Promise<Parser>;
+    getActiveParser(vertical: string): Promise<Parser>;
+    listWebhooks(): Promise<{
+        data: Webhook[];
+    }>;
+    createWebhook(webhook: CreateWebhook): Promise<Webhook>;
+    deleteWebhook(webhookId: string): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,271 @@
+import { WedeError, WedeAuthError, WedeNetworkError } from './errors.js';
+import { sha256Hex, uuid } from './crypto.js';
+const DEFAULT_BASE_URL = 'https://api.wede.pt';
+const DEFAULT_TIMEOUT = 10_000;
+const DEFAULT_RETRIES = 3;
+export const SDK_VERSION = '2.0.0';
+/**
+ * Integrity checksum expected by POST /v1/sync/batch:
+ * SHA-256 (hex) of JSON.stringify(payload) + idempotency_key + offline_generated_at.
+ */
+export async function integrityHash(payload, idempotencyKey, offlineGeneratedAt) {
+    return sha256Hex(JSON.stringify(payload) + idempotencyKey + offlineGeneratedAt);
+}
+/**
+ * Captures an event at the moment it happens, without connectivity.
+ * Store the returned object as is; do not change the payload afterwards.
+ */
+export async function captureEvent(event, connectivityState) {
+    const idempotency_key = event.idempotency_key ?? uuid();
+    const offline_generated_at = new Date().toISOString();
+    const integrity_hash = await integrityHash(event.payload, idempotency_key, offline_generated_at);
+    const captured = {
+        type: event.type,
+        vertical: event.vertical,
+        priority: event.priority,
+        idempotency_key,
+        payload: event.payload,
+        offline_generated_at,
+        integrity_hash,
+    };
+    if (connectivityState)
+        captured.connectivity_state_at_generation = connectivityState;
+    return captured;
+}
+export class WedeClient {
+    apiKey;
+    accessToken;
+    baseUrl;
+    timeout;
+    retries;
+    constructor(options) {
+        if (!options?.apiKey && !options?.accessToken)
+            throw new WedeAuthError('apiKey or accessToken is required');
+        if (options.apiKey && options.accessToken)
+            throw new WedeAuthError('Use apiKey or accessToken, not both');
+        this.apiKey = options.apiKey;
+        this.accessToken = options.accessToken;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.retries = options.retries ?? DEFAULT_RETRIES;
+    }
+    /**
+     * Signs a user in and returns a session token for WedeClient({ accessToken }).
+     * Five failed attempts lock the account for 15 minutes.
+     */
+    static async login(email, password, options) {
+        const baseUrl = (options?.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), options?.timeout ?? DEFAULT_TIMEOUT);
+        let res;
+        try {
+            res = await fetch(baseUrl + '/v1/auth/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password }),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            throw new WedeNetworkError(err instanceof Error ? err.message : undefined);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const data = await res.json().catch(() => ({}));
+        if (res.status === 401)
+            throw new WedeAuthError(data?.message ?? 'Invalid email or password');
+        if (!res.ok)
+            throw new WedeError(data?.message ?? `Login failed with status ${res.status}`, data?.error ?? 'api_error', res.status);
+        return data;
+    }
+    /** Replaces the session token, for example after signing in again. */
+    setAccessToken(token) {
+        if (!this.accessToken)
+            throw new WedeAuthError('This client uses an API key');
+        this.accessToken = token;
+    }
+    authHeader() {
+        return this.apiKey ? { 'X-Wede-API-Key': this.apiKey } : { Authorization: `Bearer ${this.accessToken}` };
+    }
+    async request(method, path, body) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.retries; attempt++) {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), this.timeout);
+            let res;
+            try {
+                res = await fetch(this.baseUrl + path, {
+                    method,
+                    headers: { ...this.authHeader(), 'Content-Type': 'application/json' },
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                lastError = err;
+                if (attempt < this.retries)
+                    await new Promise(r => setTimeout(r, 300 * attempt));
+                continue;
+            }
+            clearTimeout(timer);
+            if (res.status === 204)
+                return undefined;
+            const text = await res.text();
+            let data = undefined;
+            if (text) {
+                try {
+                    data = JSON.parse(text);
+                }
+                catch {
+                    data = { message: text };
+                }
+            }
+            if (res.status === 401)
+                throw new WedeAuthError(data?.message);
+            if (!res.ok) {
+                throw new WedeError(data?.message ?? `Request failed with status ${res.status}`, data?.error ?? 'api_error', res.status, data?.details);
+            }
+            return data;
+        }
+        throw new WedeNetworkError(lastError instanceof Error ? lastError.message : undefined);
+    }
+    qs(params) {
+        if (!params)
+            return '';
+        const entries = Object.entries(params).filter(([, v]) => v !== undefined && v !== null);
+        if (entries.length === 0)
+            return '';
+        return '?' + new URLSearchParams(entries.map(([k, v]) => [k, String(v)])).toString();
+    }
+    // ── Events ─────────────────────────────────────────────────────────────
+    /** Submits an event. Same idempotency_key twice returns 409 duplicate_event. */
+    sendEvent(event) {
+        return this.request('POST', '/v1/events', { ...event, idempotency_key: event.idempotency_key ?? uuid() });
+    }
+    listEvents(params) {
+        return this.request('GET', '/v1/events' + this.qs(params));
+    }
+    getEvent(eventId) {
+        return this.request('GET', '/v1/events/' + encodeURIComponent(eventId));
+    }
+    // ── Offline capture and batch sync ─────────────────────────────────────
+    /** Sends events captured with captureEvent(). Up to 500 per call. */
+    syncBatch(events) {
+        return this.request('POST', '/v1/sync/batch', { events });
+    }
+    getSyncStatus() {
+        return this.request('GET', '/v1/sync/status');
+    }
+    // ── Device queue ───────────────────────────────────────────────────────
+    registerDevice(params) {
+        return this.request('POST', '/v1/devices/register', params);
+    }
+    syncDeviceQueue(params) {
+        return this.request('POST', '/v1/devices/sync', params);
+    }
+    // ── Connectivity and zones ─────────────────────────────────────────────
+    getConnectivityStatus(zoneId) {
+        return this.request('GET', '/v1/connectivity/status' + this.qs({ zone_id: zoneId }));
+    }
+    reportConnectivity(report) {
+        return this.request('POST', '/v1/connectivity/report', {
+            ...report,
+            detected_at: report.detected_at ?? new Date().toISOString(),
+        });
+    }
+    listZones() {
+        return this.request('GET', '/v1/tenant/zones');
+    }
+    getZone(zoneCode) {
+        return this.request('GET', '/v1/tenant/zones/' + encodeURIComponent(zoneCode));
+    }
+    // ── Tenant ─────────────────────────────────────────────────────────────
+    getTenantInfo() {
+        return this.request('GET', '/v1/tenant/me');
+    }
+    /** from and to are ISO 8601 dates. */
+    getUsage(from, to) {
+        return this.request('GET', '/v1/tenant/usage' + this.qs({ from, to }));
+    }
+    getBilling() {
+        return this.request('GET', '/v1/tenant/billing');
+    }
+    updateDispatchSettings(settings) {
+        return this.request('PATCH', '/v1/tenant/dispatch-settings', settings);
+    }
+    // ── Teams and dispatch ─────────────────────────────────────────────────
+    listTeams() {
+        return this.request('GET', '/v1/teams');
+    }
+    getTeam(teamId) {
+        return this.request('GET', '/v1/teams/' + encodeURIComponent(teamId));
+    }
+    updateMemberLocation(teamId, memberId, lat, lng) {
+        return this.request('PATCH', `/v1/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(memberId)}/location`, { lat, lng });
+    }
+    /** Free teams ranked by best conditions (score 0 to 1, higher is better). */
+    scoreTeams(params) {
+        return this.request('POST', '/v1/teams/dispatch/score', params);
+    }
+    /** Dispatches a specific team to an event. */
+    dispatch(params) {
+        return this.request('POST', '/v1/teams/dispatch', params);
+    }
+    /** Scores and, if automatic dispatch is on, dispatches for a catalog action. */
+    dispatchAction(params) {
+        return this.request('POST', '/v1/teams/dispatch/action', params);
+    }
+    // ── Missions ───────────────────────────────────────────────────────────
+    listMissions(params) {
+        return this.request('GET', '/v1/missions' + this.qs(params));
+    }
+    /** Missions assigned to the authenticated field user. */
+    listMyMissions() {
+        return this.request('GET', '/v1/missions/my');
+    }
+    getMission(missionId) {
+        return this.request('GET', '/v1/missions/' + encodeURIComponent(missionId));
+    }
+    updateMissionStatus(missionId, status, feedback) {
+        return this.request('PATCH', `/v1/missions/${encodeURIComponent(missionId)}/status`, { status, feedback });
+    }
+    // ── Event categories ───────────────────────────────────────────────────
+    /** The open list of event categories kept by wede. */
+    listEventCategories() {
+        return this.request('GET', '/v1/event-categories');
+    }
+    // ── Catalog (your event types) and parsers ─────────────────────────────
+    listCatalogActions(vertical) {
+        return this.request('GET', '/v1/catalog/actions' + this.qs({ vertical }));
+    }
+    createCatalogAction(action) {
+        return this.request('POST', '/v1/catalog/actions', action);
+    }
+    updateCatalogAction(actionId, changes) {
+        return this.request('PATCH', '/v1/catalog/actions/' + encodeURIComponent(actionId), changes);
+    }
+    deleteCatalogAction(actionId) {
+        return this.request('DELETE', '/v1/catalog/actions/' + encodeURIComponent(actionId));
+    }
+    listParsers() {
+        return this.request('GET', '/v1/parsers');
+    }
+    getParser(parserId) {
+        return this.request('GET', '/v1/parsers/' + encodeURIComponent(parserId));
+    }
+    getActiveParser(vertical) {
+        return this.request('GET', `/v1/parsers/vertical/${encodeURIComponent(vertical)}/active`);
+    }
+    // ── Webhooks ───────────────────────────────────────────────────────────
+    listWebhooks() {
+        return this.request('GET', '/v1/webhooks');
+    }
+    createWebhook(webhook) {
+        return this.request('POST', '/v1/webhooks', webhook);
+    }
+    deleteWebhook(webhookId) {
+        return this.request('DELETE', '/v1/webhooks/' + encodeURIComponent(webhookId));
+    }
+}

package/dist/crypto.d.ts

@@ -0,0 +1,6 @@
+/** Plain JavaScript SHA-256, used only when Web Crypto is not available. */
+export declare function sha256Fallback(data: Uint8Array): Uint8Array;
+/** SHA-256 of a UTF-8 string, as lowercase hex. */
+export declare function sha256Hex(text: string): Promise<string>;
+/** Random UUID v4. */
+export declare function uuid(): string;

package/dist/crypto.js

@@ -0,0 +1,114 @@
+// Runtime-independent helpers. Use Web Crypto when the runtime has it (Node 20+,
+// browsers, Workers, Deno, Bun) and fall back to plain JavaScript otherwise
+// (React Native without a crypto polyfill).
+function utf8(text) {
+    if (typeof TextEncoder !== 'undefined')
+        return new TextEncoder().encode(text);
+    const out = [];
+    for (const ch of text) {
+        let cp = ch.codePointAt(0);
+        if (cp >= 0xd800 && cp <= 0xdfff)
+            cp = 0xfffd; // lone surrogate, same as TextEncoder
+        if (cp < 0x80)
+            out.push(cp);
+        else if (cp < 0x800)
+            out.push(0xc0 | (cp >> 6), 0x80 | (cp & 63));
+        else if (cp < 0x10000)
+            out.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+        else
+            out.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 63), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+    }
+    return new Uint8Array(out);
+}
+function hex(bytes) {
+    let s = '';
+    for (let i = 0; i < bytes.length; i++)
+        s += bytes[i].toString(16).padStart(2, '0');
+    return s;
+}
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** Plain JavaScript SHA-256, used only when Web Crypto is not available. */
+export function sha256Fallback(data) {
+    const bitLen = data.length * 8;
+    const padded = new Uint8Array(((data.length + 9 + 63) >> 6) << 6);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bitLen / 0x100000000));
+    view.setUint32(padded.length - 4, bitLen >>> 0);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < padded.length; off += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(off + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]];
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const ov = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++)
+        ov.setUint32(i * 4, h[i]);
+    return out;
+}
+/** SHA-256 of a UTF-8 string, as lowercase hex. */
+export async function sha256Hex(text) {
+    const bytes = utf8(text);
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle)
+        return hex(new Uint8Array(await subtle.digest('SHA-256', bytes)));
+    return hex(sha256Fallback(bytes));
+}
+/** Random UUID v4. */
+export function uuid() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    const b = new Uint8Array(16);
+    if (c?.getRandomValues)
+        c.getRandomValues(b);
+    else
+        for (let i = 0; i < 16; i++)
+            b[i] = Math.floor(Math.random() * 256);
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const h = hex(b);
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class WedeError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, status?: number | undefined, details?: unknown | undefined);
+}
+export declare class WedeAuthError extends WedeError {
+    constructor(message?: string);
+}
+export declare class WedeNetworkError extends WedeError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,24 @@
+export class WedeError extends Error {
+    code;
+    status;
+    details;
+    constructor(message, code, status, details) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.name = 'WedeError';
+    }
+}
+export class WedeAuthError extends WedeError {
+    constructor(message = 'Invalid or missing credentials') {
+        super(message, 'unauthorized', 401);
+        this.name = 'WedeAuthError';
+    }
+}
+export class WedeNetworkError extends WedeError {
+    constructor(message = 'Network request failed') {
+        super(message, 'network_error');
+        this.name = 'WedeNetworkError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { WedeClient, captureEvent, integrityHash, SDK_VERSION } from './client.js';
+export { WedeError, WedeAuthError, WedeNetworkError } from './errors.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { WedeClient, captureEvent, integrityHash, SDK_VERSION } from './client.js';
+export { WedeError, WedeAuthError, WedeNetworkError } from './errors.js';

package/dist/types.d.ts

@@ -0,0 +1,374 @@
+/**
+ * Event type. Either the code of an action in your catalog for the event's
+ * vertical (for example "cardiac_arrest"), or the code of an active event
+ * category used directly (for example "STATUS_UPDATE"). Letters, digits and _.
+ */
+export type EventType = string;
+/** An event category. wede keeps this list open; categories are never required. */
+export interface EventCategory {
+    code: string;
+    label: string;
+    description: string | null;
+    is_active: boolean;
+}
+export type Priority = 'low' | 'normal' | 'high' | 'critical';
+export type ConnectivityState = 'online' | 'degraded' | 'sms_only' | 'voice_only' | 'offline';
+export type MissionStatus = 'CREATED' | 'SENT' | 'ACK' | 'ON_ROUTE' | 'ON_SITE' | 'COMPLETED' | 'FAILED';
+export type WebhookEventName = 'event.created' | 'event.status_changed' | 'event.delivered' | 'event.failed' | 'sync.completed' | 'connectivity.degraded' | 'connectivity.restored' | 'assignment.created' | 'team.created' | 'team.updated' | 'team.deleted' | 'team.dispatched' | 'team.equipment.added' | 'team.equipment.updated' | 'team.equipment.removed' | 'mission.created' | 'mission.status_updated';
+export interface WedeClientOptions {
+    /** Tenant API key (wede_live_... or wede_test_...). Server side only. */
+    apiKey?: string;
+    /** Session token of a user (see WedeClient.login). Use this on devices. */
+    accessToken?: string;
+    /** Defaults to https://api.wede.pt */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 10000. */
+    timeout?: number;
+    /** Attempts on network failure. Defaults to 3. */
+    retries?: number;
+}
+export interface EventMetadata {
+    zone_id?: string;
+    operator_id?: string;
+    sdk_version?: string;
+    offline_generated_at?: string;
+    connectivity_state_at_generation?: ConnectivityState;
+}
+/** One-off recipient for this event only. Never stored by wede. */
+export interface EventDestination {
+    phone?: string;
+    email?: string;
+    device_id?: string;
+}
+export interface EventInput {
+    type: EventType;
+    /** A vertical registered for your tenant, for example "healthcare". */
+    vertical: string;
+    priority: Priority;
+    /** Unique per operation. Generated by the SDK when omitted. */
+    idempotency_key?: string;
+    payload: Record<string, unknown>;
+    metadata?: EventMetadata;
+    destination?: EventDestination;
+}
+export interface SendEventResult {
+    event_id: string;
+    idempotency_key: string;
+    status: string;
+    channel_selected: string;
+    estimated_delivery_ms: number;
+    request_id: string;
+}
+export interface EventSummary {
+    event_id: string;
+    /** Your event type. Absent for wede platform roles, which only see the category. */
+    type?: EventType;
+    category: string;
+    vertical: string;
+    priority: Priority;
+    status: string;
+    channel_used: string | null;
+    created_at: string;
+    updated_at: string;
+    zone_id: string | null;
+}
+export interface EventList {
+    data: EventSummary[];
+    next_cursor: string | null;
+    total_count: number;
+}
+export interface EventLifecycleEntry {
+    status: string;
+    channel: string | null;
+    note: string | null;
+    timestamp: string;
+}
+export interface EventDetail {
+    id: string;
+    /** Your event type. Absent for wede platform roles, which only see the category. */
+    type?: EventType;
+    category: string;
+    vertical: string;
+    priority: Priority;
+    status: string;
+    lifecycle: EventLifecycleEntry[];
+    [key: string]: unknown;
+}
+export interface ListEventsParams {
+    status?: string;
+    type?: EventType;
+    category?: string;
+    vertical?: string;
+    zone_id?: string;
+    /** Up to 200. Defaults to 50. */
+    limit?: number;
+}
+/** An event captured without connectivity, ready for syncBatch(). */
+export interface CapturedEvent {
+    type: EventType;
+    vertical: string;
+    priority: Priority;
+    idempotency_key: string;
+    payload: Record<string, unknown>;
+    /** ISO 8601 moment of capture. */
+    offline_generated_at: string;
+    connectivity_state_at_generation?: ConnectivityState;
+    /** SHA-256 hex, computed by captureEvent(). */
+    integrity_hash: string;
+}
+export type SyncItemResult = 'accepted' | 'duplicate' | 'rejected';
+export interface SyncBatchResult {
+    summary: {
+        total: number;
+        accepted: number;
+        duplicates: number;
+        rejected: number;
+    };
+    results: Array<{
+        idempotency_key: string;
+        event_id: string | null;
+        result: SyncItemResult;
+        error_code: string | null;
+        error_message: string | null;
+    }>;
+}
+export interface SyncStatus {
+    tenant_id: string;
+    synced_total: number;
+    pending: number;
+    completed: number;
+    failed: number;
+    last_sync_at: string | null;
+}
+export interface RegisterDeviceParams {
+    device_id: string;
+    platform: 'ios' | 'android' | 'web' | 'other';
+    app_version?: string;
+}
+export interface DeviceQueueItem {
+    /** Starts at 1, increases by one per operation, never reused or skipped. */
+    sequence_number: number;
+    action_id?: string;
+    event_lat?: number;
+    event_lng?: number;
+    vertical?: string;
+    priority?: string;
+    payload?: Record<string, unknown>;
+    created_offline_at: string;
+}
+export interface SyncDeviceQueueParams {
+    device_id: string;
+    last_received_seq: number;
+    /** Up to 500 per call. */
+    dispatches: DeviceQueueItem[];
+}
+export interface SyncDeviceQueueResult {
+    accepted: number[];
+    duplicates: number[];
+    failed: number[];
+    server_seq: number;
+    device_last_received_seq: number;
+    synced_at: string;
+    integrity_gap_detected: boolean;
+    integrity_incident_id: string | null;
+}
+export interface ZoneConnectivity {
+    zone_id: string;
+    zone_name: string;
+    country: string;
+    state: ConnectivityState;
+    incident_active: boolean;
+    last_updated: string;
+    fallback_channel: string;
+}
+export interface ConnectivityStatus {
+    zones: ZoneConnectivity[];
+    as_of: string;
+}
+export interface ConnectivityReport {
+    zone_id: string;
+    state: ConnectivityState;
+    /** ISO 8601. Defaults to now. */
+    detected_at?: string;
+    signal_strength_dbm?: number | null;
+    network_type?: 'wifi' | 'lte' | 'umts' | 'edge' | 'gprs' | 'gsm' | 'none' | null;
+    device_id?: string;
+}
+export interface Zone {
+    zone_code: string;
+    name: string;
+    [key: string]: unknown;
+}
+export interface ZoneList {
+    zones: Zone[];
+    total: number;
+}
+export interface TenantInfo {
+    id: string;
+    name: string;
+    zones: unknown[];
+    [key: string]: unknown;
+}
+export interface Usage {
+    tenant_id: string;
+    period: {
+        from: string;
+        to: string;
+    };
+    totals: {
+        events: number;
+        offline_events: number;
+        sms_messages: number;
+        voice_calls: number;
+    };
+    limits: Record<string, number>;
+    by_vertical: Record<string, number>;
+    by_channel: Record<string, number>;
+}
+export interface Billing {
+    tenant_id: string;
+    country: string;
+    current_plan: Record<string, unknown> | null;
+    available_plans: Record<string, unknown>[];
+    channel_costs: Record<string, unknown>[];
+    usage: Record<string, number>;
+}
+export interface DispatchSettings {
+    dispatch_mode: boolean;
+    dispatch_threshold: number;
+    reinforcement_timeout_min: number;
+}
+export interface Team {
+    id: string;
+    name: string;
+    vertical: string;
+    status: string;
+    members: Record<string, unknown>[];
+    [key: string]: unknown;
+}
+export interface TeamList {
+    data: Team[];
+    count: number;
+}
+export interface ScoreTeamsParams {
+    lat: number;
+    lng: number;
+    vertical?: string;
+    priority?: string;
+    required_equipment?: string[];
+}
+export interface ScoredTeam {
+    team_id: string;
+    team_name: string;
+    status: string;
+    distance_km: number;
+    eta_min: number;
+    /** 0 to 1, higher means better conditions. */
+    score: number;
+    recommended: boolean;
+    channel: string;
+    [key: string]: unknown;
+}
+export interface ScoreTeamsResult {
+    scored: ScoredTeam[];
+    count: number;
+}
+export interface DispatchParams {
+    event_id: string;
+    team_id: string;
+    notes?: string;
+    event_lat?: number;
+    event_lng?: number;
+}
+export interface DispatchActionParams {
+    /** Id of an action in your catalog. */
+    action_id: string;
+    lat: number;
+    lng: number;
+    priority?: string;
+    /** Your event id. Generated by wede when omitted. */
+    event_id?: string;
+}
+export interface Mission {
+    id: string;
+    event_id: string;
+    team_id: string;
+    status: MissionStatus;
+    [key: string]: unknown;
+}
+export interface MissionList {
+    data: Mission[];
+    count: number;
+}
+export interface ListMissionsParams {
+    team_id?: string;
+    status?: MissionStatus;
+    limit?: number;
+}
+export interface CatalogAction {
+    id: string;
+    vertical: string;
+    code: string;
+    name: string;
+    description?: string | null;
+    /** Event category of this type. Defaults to OTHER. */
+    category: string;
+    is_active: boolean;
+    [key: string]: unknown;
+}
+export interface CreateCatalogAction {
+    vertical: string;
+    /** Lowercase letters, digits and underscores. Cannot be the code of a category. */
+    code: string;
+    name: string;
+    description?: string;
+    /** Code of an active event category. Defaults to OTHER. */
+    category?: string;
+}
+export interface UpdateCatalogAction {
+    name?: string;
+    description?: string;
+    is_active?: boolean;
+    /** Applies to new events only; events already stored keep their category. */
+    category?: string;
+}
+export interface LoginResult {
+    token: string;
+    /** Seconds. */
+    expires_in: number;
+    user: {
+        id: string;
+        email: string;
+        name: string | null;
+        rbac_level: string;
+        [key: string]: unknown;
+    };
+}
+export interface Parser {
+    id: string;
+    vertical: string;
+    name: string;
+    [key: string]: unknown;
+}
+export interface ParserList {
+    data: Parser[];
+    count: number;
+}
+export interface Webhook {
+    webhook_id: string;
+    url: string;
+    events: WebhookEventName[];
+    active: boolean;
+    description: string | null;
+    created_at: string;
+    failure_count: number;
+    [key: string]: unknown;
+}
+export interface CreateWebhook {
+    url: string;
+    events: WebhookEventName[];
+    /** At least 16 characters. Used to sign deliveries. */
+    secret: string;
+    active?: boolean;
+    description?: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+// Types mirror the responses of the wede API as implemented.
+// Where the API returns a full record whose columns may evolve, the record
+// is typed with its stable identifiers plus an index signature.
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@wedetech/sdk",
+  "version": "2.0.0",
+  "description": "Official JavaScript and TypeScript client for the wede API (Node.js, browsers, edge runtimes and React Native)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && node --test test/unit.test.mjs",
+    "test:integration": "tsc && node --test test/integration.test.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "wede",
+    "operational-continuity",
+    "offline-first",
+    "sdk",
+    "react-native"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Wedeadmin/wedetech-sdk-js.git"
+  },
+  "homepage": "https://docs.wede.pt",
+  "publishConfig": {
+    "access": "public"
+  }
+}