@deveye/types 0.15.0

package/src/domain/sharing.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+
+import { featureAccessSchema, workspaceFeatureIdSchema } from './workspaceRole';
+
+/**
+ * Rendre un élément visible depuis un autre espace, **sans le déplacer**.
+ *
+ * ## L'invariant, avant tout le reste
+ *
+ * Un élément partagé **ne change jamais de clé**. Il reste chiffré sous celle de
+ * son espace d'origine ; servi ailleurs, il est déchiffré avec le codec ouvert
+ * de cet espace-là. C'est le prolongement direct du levier L3 de
+ * `WORKSPACES.md` — « un espace résout les clés de son propriétaire » — et la
+ * raison pour laquelle ce chantier ne re-chiffre rien.
+ *
+ * `WORKSPACES.md` §10 range **déplacer** un élément hors périmètre, précisément
+ * parce que ce serait la seule opération à exiger un déchiffrement clé A puis un
+ * re-chiffrement clé B sous session vivante. Partager ne l'exige pas : c'est une
+ * **projection**, pas un transfert. L'élément a un seul domicile, et des
+ * fenêtres ailleurs.
+ *
+ * ## Ce qui en découle, et qu'il faut assumer
+ *
+ * Seule la clé de l'étage ouvert est résoluble par le serveur seul. Un élément
+ * de l'étage gardé ne peut donc pas être partagé — pas par prudence, par
+ * impossibilité mécanique. Voir `shareTier` dans le registre.
+ *
+ * ## On ne partage qu'avec soi-même
+ *
+ * La liste proposée est celle des espaces **dont l'appelant est membre**. Ce
+ * n'est pas une restriction d'interface mais la règle : partager vers un espace
+ * où l'on n'entre pas reviendrait à y déposer une donnée sans pouvoir en
+ * répondre, et à contourner l'appartenance — qui est la frontière absolue du
+ * modèle (`WORKSPACES.md` §3).
+ */
+
+export const itemShareSchema = z.object({
+    /** L'espace vers lequel l'élément est projeté. */
+    workspaceId: z.number().int().positive(),
+    workspaceName: z.string(),
+    /** Faux quand c'est l'espace d'origine : il n'est pas décochable. */
+    isHome: z.boolean(),
+    shared: z.boolean(),
+    /**
+     * L'appelant peut régler, **depuis ici**, ce que chaque rôle de cet espace
+     * voit de l'élément (`share.grantList` / `share.grantSet` avec ce
+     * `workspaceId`).
+     *
+     * Vrai quand l'élément y est visible, que l'espace est partagé (un espace
+     * personnel n'a pas de rôles) et que l'appelant y tient `workspace.roles`.
+     * C'est ce qui permet de gérer les permissions de toutes les fenêtres
+     * depuis l'onglet Partage, sans changer d'espace.
+     */
+    grantsManageable: z.boolean()
+});
+export type ItemShare = z.infer<typeof itemShareSchema>;
+
+/**
+ * Pourquoi un élément ne peut pas être partagé, quand c'est le cas.
+ *
+ * Une phrase plutôt qu'un booléen : « impossible » sans raison donne à chercher
+ * un réglage qui n'existe pas. Ici la cause est toujours structurelle, et la
+ * dire évite qu'on la prenne pour une panne.
+ */
+export const shareBlockerSchema = z.enum([
+    /** La fonctionnalité entière vit à l'étage gardé, ou n'a pas de sens ici. */
+    'feature',
+    /** Cet élément précis est gardé — note privée, compte mail « guarded ». */
+    'item',
+    /** L'appelant n'a pas le droit de partager cette fonctionnalité. */
+    'forbidden',
+    /**
+     * L'élément vient d'un autre espace : on ne re-projette pas ce qu'on ne
+     * fait que voir. Son partage se règle depuis chez lui.
+     */
+    'foreign'
+]);
+export type ShareBlocker = z.infer<typeof shareBlockerSchema>;
+
+export const itemShareStateSchema = z.object({
+    /** Les espaces de l'appelant, l'origine comprise et marquée. */
+    workspaces: z.array(itemShareSchema),
+    /** Renseigné quand le partage est impossible ; les cases sont alors inertes. */
+    blocker: shareBlockerSchema.nullable()
+});
+export type ItemShareState = z.infer<typeof itemShareStateSchema>;
+
+/**
+ * Ce qu'un rôle peut faire sur **un** élément.
+ *
+ * Volontairement **restrictif seulement** : `none` ou `read` abaissent ce que le
+ * rôle a sur la fonctionnalité, jamais l'inverse. Le droit de feature reste le
+ * plafond, ici comme pour les droits fins.
+ *
+ * L'alternative — permettre d'élever — a été écartée : l'accès effectif à une
+ * fonctionnalité deviendrait « le maximum entre le rôle et le meilleur droit
+ * d'élément », donc une requête de plus dans la résolution d'accès, et surtout
+ * un écran des rôles qui ne dirait plus à lui seul qui voit quoi.
+ */
+export const itemAccessSchema = z.enum(['none', 'read']);
+export type ItemAccess = z.infer<typeof itemAccessSchema>;
+
+export const itemRoleGrantSchema = z.object({
+    roleId: z.number().int().positive(),
+    /** Absent de la liste = le rôle garde ce que la fonctionnalité lui donne. */
+    access: itemAccessSchema
+});
+export type ItemRoleGrant = z.infer<typeof itemRoleGrantSchema>;
+
+/**
+ * Un rôle d'un espace, vu depuis l'écran des restrictions d'un élément.
+ *
+ * Porte tout ce que l'écran affiche, pour qu'il n'ait **aucun** recoupement à
+ * faire : l'identité du rôle, ce que la fonctionnalité lui donne (le droit
+ * *hérité*, affiché même quand aucune exception n'est posée — une vue
+ * d'ensemble qui ne montre que les exceptions oblige à deviner le reste), et
+ * l'exception posée s'il y en a une.
+ */
+export const itemRoleGrantViewSchema = z.object({
+    roleId: z.number().int().positive(),
+    name: z.string(),
+    color: z.string(),
+    /**
+     * Ce que le rôle a sur la **fonctionnalité** — le plafond, et la valeur
+     * effective quand `access` est `null`.
+     */
+    featureAccess: z.enum(['none', 'read', 'write']),
+    /** L'exception posée sur cet élément, ou `null` : « comme la fonctionnalité ». */
+    access: itemAccessSchema.nullable()
+});
+export type ItemRoleGrantView = z.infer<typeof itemRoleGrantViewSchema>;
+
+/** L'état des restrictions d'un élément dans **un** espace, prêt à afficher. */
+export const itemGrantStateSchema = z.object({
+    workspaceId: z.number().int().positive(),
+    workspaceName: z.string(),
+    roles: z.array(itemRoleGrantViewSchema)
+});
+export type ItemGrantState = z.infer<typeof itemGrantStateSchema>;
+
+/** La cible d'un partage ou d'une restriction. */
+export const itemRefSchema = z.object({
+    feature: workspaceFeatureIdSchema,
+    itemId: z.number().int().positive()
+});
+export type ItemRef = z.infer<typeof itemRefSchema>;
+
+/**
+ * Une référence qu'on voit sans pouvoir la lire.
+ *
+ * Le cas : un élément partagé vers B pointe une donnée de A — un compte mail, un
+ * appareil, un canal d'alerte. Un membre de B qui n'est pas membre de A doit
+ * **savoir que le lien existe** sans en connaître le contenu. Le masquer
+ * entièrement ferait croire à un élément mal réglé ; le montrer ferait fuiter
+ * l'espace d'origine.
+ *
+ * Il peut la **retirer** si ses droits le permettent — retirer un lien ne
+ * demande pas de le lire. Il ne peut ni le voir ni le modifier.
+ */
+export const foreignRefSchema = z.object({
+    kind: z.literal('inaccessible'),
+    /** « Compte mail d'un autre espace » — le genre, jamais l'identité. */
+    label: z.string()
+});
+export type ForeignRef = z.infer<typeof foreignRefSchema>;
+
+/** Ligne de `item_shares` (serveur uniquement). */
+export interface ItemShareRow {
+    workspace_id: number;
+    feature: string;
+    item_id: number;
+    home_workspace_id: number;
+    shared_by_user_id: number;
+    created: number;
+}
+
+/** Ligne de `item_role_grants` (serveur uniquement). */
+export interface ItemRoleGrantRow {
+    workspace_id: number;
+    feature: string;
+    item_id: number;
+    role_id: number;
+    access: ItemAccess;
+}
+
+export { featureAccessSchema };

package/src/domain/syncProtocol.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+
+/**
+ * La part PUBLIQUE du vocabulaire CloudSync : ce que le protocole agent
+ * transporte (scan, index, progression, état de partage) et rien d'autre.
+ *
+ * Le reste du domaine CloudSync (partages, versions, instantanés, lignes SQL)
+ * vit dans le module privé deveye-feature-cloudsync : seul le fil, parlé par
+ * l'agent public et poussé aux navigateurs, appartient au contrat publié.
+ */
+/** Bornes partagées serveur/agent/client. */
+export const SYNC_REL_PATH_MAX = 1024;
+export const SYNC_PATTERN_MAX = 512;
+export const SYNC_STORAGE_PATH_MAX = 1024;
+/** Taille max d'un chunk base64 sur le fil (≈ 1 Mo de binaire). */
+export const SYNC_CHUNK_MAX = 1_400_000;
+/** Nombre max d'entrées d'index par frame `sync.index`. */
+export const SYNC_INDEX_BATCH_MAX = 500;
+/**
+ * Séparateur des champs d'une ligne d'empreinte d'index (voir
+ * `src/cloudSync/fingerprint.ts` côté serveur et `sync::fingerprint` côté
+ * agent). U+0001 est sûr : les caractères de contrôle sont déjà refusés dans un
+ * chemin par `relPathProblem` / `rel_path_problem`, des deux côtés.
+ */
+export const SYNC_FINGERPRINT_SEP = '\u0001';
+/**
+ * Mode de scan demandé à l'agent.
+ *  - `auto` → l'agent a le droit de répondre « rien n'a bougé » sans parcourir
+ *    le disque, en se contentant d'annoncer l'empreinte de ce qu'il détient ;
+ *  - `full` → parcours complet obligatoire (filet de sécurité horaire).
+ */
+export const syncScanModeSchema = z.enum(['auto', 'full']);
+export type SyncScanMode = z.infer<typeof syncScanModeSchema>;
+/**
+ * Empreinte d'un index : `{nombre}.{octets}.{sha256hex}`.
+ *
+ * Le pli est un XOR des hachages par ligne, donc INDÉPENDANT DE L'ORDRE, et
+ * c'est délibéré : un tri obligerait Rust (ordre octet UTF-8) et TypeScript
+ * (ordre unité UTF-16) à s'accorder sur les caractères hors BMP, ce qu'ils ne
+ * font pas. Un seul emoji dans un nom de fichier aurait alors désactivé le
+ * chemin rapide pour toujours, sans que rien ne le signale.
+ */
+export const syncIndexFingerprintSchema = z.string().regex(/^\d+\.\d+\.[0-9a-f]{64}$/);
+/** SHA-256 hexadécimal (du clair d'un fichier, ou d'un chemin normalisé). */
+export const sha256HexSchema = z.string().regex(/^[a-f0-9]{64}$/);
+export const syncShareStatusSchema = z.enum(['active', 'paused']);
+export type SyncShareStatus = z.infer<typeof syncShareStatusSchema>;
+/**
+ * Type d'exclusion :
+ *  - `path`  → chemin relatif exact (fichier ou préfixe de dossier),
+ *  - `name`  → nom exact d'un composant de chemin (ex. `node_modules`),
+ *  - `regex` → expression régulière sur le chemin relatif (moteur linéaire).
+ */
+export const syncExclusionKindSchema = z.enum(['path', 'name', 'regex']);
+export type SyncExclusionKind = z.infer<typeof syncExclusionKindSchema>;
+export const syncSessionStateSchema = z.enum([
+    'scanning',
+    'planning',
+    'transferring',
+    'done',
+    'error',
+    'cancelled'
+]);
+export type SyncSessionState = z.infer<typeof syncSessionStateSchema>;
+/**
+ * Nature d'une entrée d'index. Seuls les dossiers VIDES sont indexés comme
+ * `dir` : un dossier peuplé est implicite (ses fichiers le recréent partout).
+ * Sans ça, un dossier vide créé sur une machine n'existerait sur aucune autre,
+ * et un dossier vidé resterait en coquille chez les pairs.
+ */
+export const syncEntryKindSchema = z.enum(['file', 'dir']);
+export type SyncEntryKind = z.infer<typeof syncEntryKindSchema>;
+/** Volumétrie d'un partage (index + versions ; tailles logiques en clair). */
+export const cloudSyncShareStatsSchema = z.object({
+    fileCount: z.number().int().nonnegative(),
+    liveBytes: z.number().int().nonnegative(),
+    versionCount: z.number().int().nonnegative(),
+    versionBytes: z.number().int().nonnegative()
+});
+export type CloudSyncShareStats = z.infer<typeof cloudSyncShareStatsSchema>;
+/** Sens du transfert en cours (du point de vue de l'appareil). */
+export const syncDirectionSchema = z.enum(['up', 'down', 'delete']);
+export type SyncDirection = z.infer<typeof syncDirectionSchema>;
+/** Progression d'une session, poussée aux clients web abonnés (throttlée). */
+export const cloudSyncProgressSchema = z.object({
+    shareId: z.number().int().positive(),
+    deviceId: z.uuid(),
+    sessionId: z.string().max(64),
+    state: syncSessionStateSchema,
+    filesTotal: z.number().int().nonnegative(),
+    bytesTotal: z.number().int().nonnegative(),
+    filesDone: z.number().int().nonnegative(),
+    bytesDone: z.number().int().nonnegative(),
+    /** Fichier en cours de transfert, pour la ligne discrète de l'UI. */
+    currentPath: z.string().max(SYNC_REL_PATH_MAX).nullable(),
+    /**
+     * Avancement DANS le fichier en cours. Sans ça, un fichier de plusieurs Go
+     * laissait la barre parfaitement figée du début à la fin de son transfert :
+     * les octets n'étaient comptés qu'une fois le fichier terminé.
+     */
+    currentBytes: z.number().int().nonnegative(),
+    currentTotal: z.number().int().nonnegative(),
+    direction: syncDirectionSchema.nullable(),
+    error: z.string().max(500).nullable()
+});
+export type CloudSyncProgress = z.infer<typeof cloudSyncProgressSchema>;
+/** État agrégé d'un partage — pilote le héros « Synchronisé » de l'UI. */
+export const cloudSyncShareStateSchema = z.object({
+    shareId: z.number().int().positive(),
+    state: z.enum(['synced', 'syncing', 'paused', 'offline', 'error']),
+    /** Précision facultative (ex. nom de l'appareil hors ligne ou en erreur). */
+    detail: z.string().max(200).nullable(),
+    /** Volumétrie fraîche — l'en-tête de l'UI se met à jour sans re-fetch. */
+    stats: cloudSyncShareStatsSchema
+});
+export type CloudSyncShareState = z.infer<typeof cloudSyncShareStateSchema>;

package/src/domain/twoFactor.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+/** Current 2FA state for the authenticated account. */
+export const twoFactorStatusSchema = z.object({
+    enabled: z.boolean(),
+    /** Remaining unused recovery codes (only meaningful when enabled). */
+    backupCodesRemaining: z.number().int().nonnegative()
+});
+
+export type TwoFactorStatus = z.infer<typeof twoFactorStatusSchema>;
+
+/**
+ * One-time provisioning payload returned when starting 2FA setup. The secret
+ * and otpauth URL are shown once; the client renders the QR code locally.
+ */
+export const twoFactorSetupSchema = z.object({
+    secret: z.string().min(1),
+    otpauthUrl: z.string().min(1),
+    backupCodes: z.array(z.string().min(1))
+});
+
+export type TwoFactorSetup = z.infer<typeof twoFactorSetupSchema>;
+
+export interface TwoFactorRow {
+    user_id: number;
+    /** Encrypted TOTP secret (zero-knowledge: never stored in clear). */
+    secret_enc: string;
+    enabled: number;
+    created: number;
+    confirmed_at: number | null;
+}
+
+export interface BackupCodeRow {
+    id: number;
+    user_id: number;
+    /** SHA-256 hash of the recovery code; raw codes are shown once to the user. */
+    code_hash: string;
+    used_at: number | null;
+    created: number;
+}

package/src/domain/uptime.ts

@@ -0,0 +1,216 @@
+import { z } from 'zod';
+
+/**
+ * Uptime monitoring: user-defined HTTP services the server pings on a schedule,
+ * with long-term history, incidents and notifications.
+ *
+ * Storage split (see `Docs/SECURITY_MODEL.md`): everything the scheduler needs
+ * to *plan* a check (cadence, timeout, enabled…) and everything a chart
+ * aggregates (status, latency, timestamps) lives in clear columns; what
+ * identifies the target — name, URL, expected keyword — and the error strings
+ * are encrypted with the **open** tier, since the checker runs in the
+ * background, with no session and no password.
+ */
+
+export const UPTIME_NAME_MAX_LENGTH = 80;
+export const UPTIME_URL_MAX_LENGTH = 2048;
+export const UPTIME_KEYWORD_MAX_LENGTH = 200;
+/** Bounds of a service's cadence, in seconds (30 s → 24 h). */
+export const UPTIME_INTERVAL_MIN = 30;
+export const UPTIME_INTERVAL_MAX = 86400;
+/** Bounds of a single request's timeout, in seconds. */
+export const UPTIME_TIMEOUT_MIN = 1;
+export const UPTIME_TIMEOUT_MAX = 120;
+/** Consecutive failures required before a service is declared down. */
+export const UPTIME_THRESHOLD_MAX = 10;
+
+/** HTTP verb used for the probe. `POST` sends no body — it only pokes the route. */
+export const uptimeMethodSchema = z.enum(['GET', 'HEAD', 'POST']);
+export type UptimeMethod = z.infer<typeof uptimeMethodSchema>;
+
+/** `unknown` = never probed yet (just created, or paused before its first check). */
+export const uptimeStatusSchema = z.enum(['up', 'down', 'unknown']);
+export type UptimeStatus = z.infer<typeof uptimeStatusSchema>;
+
+/**
+ * How long a service keeps its **raw** per-ping rows. The daily rollup is never
+ * pruned, so uptime ratios stay readable years back whatever this is set to.
+ * `null` = keep every ping forever (the default).
+ */
+export const uptimeRetentionSchema = z.number().int().positive().max(3650).nullable();
+
+/** Window a chart or a ratio is computed over. */
+export const uptimeRangeSchema = z.enum(['24h', '7d', '30d', '90d', '1y', 'all']);
+export type UptimeRange = z.infer<typeof uptimeRangeSchema>;
+
+/**
+ * Bucket size the server picked for a history query: one point per ping (`raw`),
+ * per hour, or per day. Chosen from the range so a year-long chart never carries
+ * hundreds of thousands of points.
+ */
+export const uptimeResolutionSchema = z.enum(['raw', 'hour', 'day']);
+export type UptimeResolution = z.infer<typeof uptimeResolutionSchema>;
+
+/** One monitored service: its configuration, its live state and its ratios. */
+export const uptimeServiceSchema = z.object({
+    id: z.number().int().positive(),
+    name: z.string(),
+    url: z.string(),
+    method: uptimeMethodSchema,
+    /** Exact status code required, or `null` to accept any 2xx/3xx. */
+    expectedStatus: z.number().int().min(100).max(599).nullable(),
+    /** Substring the response body must contain, or `null` to skip the check. */
+    keyword: z.string().nullable(),
+    intervalSeconds: z.number().int().positive(),
+    timeoutSeconds: z.number().int().positive(),
+    failureThreshold: z.number().int().positive(),
+    retentionDays: uptimeRetentionSchema,
+    /** Paused services keep their history but are never probed. */
+    enabled: z.boolean(),
+    /** Rank in the list; only the user's drag & drop changes it. */
+    sortOrder: z.number().int().nonnegative(),
+    /**
+     * Ce service vient d'un **autre espace**, qui le projette ici.
+     *
+     * Il se lit et se modifie normalement — c'est tout l'objet de la projection
+     * — mais l'écran le signale : sans ça, le supprimer depuis l'espace où on le
+     * voit donnerait l'impression de retirer une ligne locale, alors qu'on
+     * toucherait la donnée d'ailleurs.
+     */
+    foreign: z.boolean(),
+
+    status: uptimeStatusSchema,
+    lastCheckedAt: z.number().int().nonnegative().nullable(),
+    lastResponseMs: z.number().int().nonnegative().nullable(),
+    lastHttpStatus: z.number().int().nullable(),
+    /** Why the last probe failed, or `null` when it succeeded. */
+    lastError: z.string().nullable(),
+    /** Start of the ongoing outage, or `null` while the service is healthy. */
+    downSince: z.number().int().nonnegative().nullable(),
+
+    /** Share of successful pings over the window (0 → 1), `null` without data. */
+    ratio24h: z.number().min(0).max(1).nullable(),
+    ratio7d: z.number().min(0).max(1).nullable(),
+    ratio30d: z.number().min(0).max(1).nullable(),
+    /** Mean response time over the last 24 h, in ms. */
+    avgMs24h: z.number().int().nonnegative().nullable(),
+
+    created: z.number().int().nonnegative()
+});
+export type UptimeService = z.infer<typeof uptimeServiceSchema>;
+
+/** A single recorded probe — the "journal des pings". */
+export const uptimeCheckSchema = z.object({
+    at: z.number().int().nonnegative(),
+    up: z.boolean(),
+    httpStatus: z.number().int().nullable(),
+    responseMs: z.number().int().nonnegative().nullable(),
+    error: z.string().nullable()
+});
+export type UptimeCheck = z.infer<typeof uptimeCheckSchema>;
+
+/**
+ * Aggregates over a filtered slice of a service's raw pings — what the measures
+ * browser shows above its list, computed over the **whole** selection rather
+ * than the loaded page.
+ */
+export const uptimeCheckStatsSchema = z.object({
+    count: z.number().int().nonnegative(),
+    failures: z.number().int().nonnegative(),
+    avgMs: z.number().int().nonnegative().nullable(),
+    minMs: z.number().int().nonnegative().nullable(),
+    maxMs: z.number().int().nonnegative().nullable(),
+    /** Bounds of the selection; `null` when it holds nothing. */
+    firstAt: z.number().int().nonnegative().nullable(),
+    lastAt: z.number().int().nonnegative().nullable()
+});
+export type UptimeCheckStats = z.infer<typeof uptimeCheckStatsSchema>;
+
+/**
+ * One chart point. A `raw` point is a single ping (`checks === 1`); an `hour` or
+ * `day` point aggregates every ping of its bucket, which is what keeps a
+ * multi-year chart cheap.
+ */
+export const uptimePointSchema = z.object({
+    /** Bucket start, epoch seconds. */
+    at: z.number().int().nonnegative(),
+    checks: z.number().int().positive(),
+    upChecks: z.number().int().nonnegative(),
+    avgMs: z.number().int().nonnegative().nullable(),
+    minMs: z.number().int().nonnegative().nullable(),
+    maxMs: z.number().int().nonnegative().nullable()
+});
+export type UptimePoint = z.infer<typeof uptimePointSchema>;
+
+/**
+ * A continuous outage. Opened when a service crosses its failure threshold,
+ * closed on the first successful probe — so the list reads as a plain incident
+ * history, and it survives raw-history pruning.
+ */
+export const uptimeIncidentSchema = z.object({
+    id: z.number().int().positive(),
+    startedAt: z.number().int().nonnegative(),
+    /** `null` while the outage is still ongoing. */
+    endedAt: z.number().int().nonnegative().nullable(),
+    httpStatus: z.number().int().nullable(),
+    error: z.string().nullable()
+});
+export type UptimeIncident = z.infer<typeof uptimeIncidentSchema>;
+
+/** Database row shapes (server-only). Mirror the columns exactly. */
+export interface UptimeServiceRow {
+    id: number;
+    user_id: number;
+    workspace_id: number;
+    /** Encrypted `{ name, url, keyword }` (open tier). */
+    content: string;
+    method: UptimeMethod;
+    expected_status: number | null;
+    interval_seconds: number;
+    timeout_seconds: number;
+    failure_threshold: number;
+    retention_days: number | null;
+    enabled: number;
+    sort_order: number;
+    status: UptimeStatus;
+    consecutive_failures: number;
+    last_checked_at: number | null;
+    last_response_ms: number | null;
+    last_http_status: number | null;
+    /** Encrypted error string (open tier), or null after a success. */
+    last_error: string | null;
+    created: number;
+}
+
+export interface UptimeCheckRow {
+    id: number;
+    service_id: number;
+    checked_at: number;
+    up: number;
+    http_status: number | null;
+    response_ms: number | null;
+    /** Encrypted error string (open tier). */
+    error: string | null;
+}
+
+export interface UptimeDayRow {
+    service_id: number;
+    day: number;
+    checks: number;
+    up_checks: number;
+    total_ms: number;
+    ms_samples: number;
+    min_ms: number | null;
+    max_ms: number | null;
+}
+
+export interface UptimeIncidentRow {
+    id: number;
+    service_id: number;
+    started_at: number;
+    ended_at: number | null;
+    http_status: number | null;
+    /** Encrypted error string (open tier). */
+    error: string | null;
+    notified: number;
+}