@aurabase/core 0.4.1 → 0.5.1

package/dist/index.d.ts

@@ -41,6 +41,42 @@ declare function isAuraError(error: unknown): error is AuraError;
 
 interface Meta {
     total?: number;
+    /**
+     * Numéro de page, quand le backend pagine par page (services non-CRUD).
+     * Absent sur le CRUD, qui pagine par `limit`/`offset` ou par curseur.
+     */
+    page?: number;
+    /**
+     * A27 — limite **réellement appliquée** par le serveur à cette réponse, plafond compris.
+     *
+     * C'est le seul moyen de détecter une troncature : une lecture sans `.limit()` est bornée
+     * (1000 lignes sur le CRUD aura-db, 1000 objets sur un listing storage), et une `.limit(n)`
+     * au-delà du plafond est rabattue en silence. Le champ était rendu par le backend mais
+     * **absent de ce type** : le plafond restait donc invisible côté TypeScript alors que la
+     * donnée était dans la réponse.
+     *
+     * Motif de détection : `data.length >= meta.per_page` ⇒ il y a probablement une suite —
+     * enchaînez avec `.range()`/`.offset()`, ou `cursor()`/`meta.next_cursor` là où il existe.
+     *
+     * ⚠️ N15 — **N'EST PAS ÉMIS SUR LE CHEMIN PostgREST**, c.-à-d. sur le CRUD d'un projet
+     * PostgreSQL, qui est le moteur NOMINAL. Le champ n'existe que sur les chemins qui
+     * connaissent la limite qu'ils ont eux-mêmes appliquée : aura-db natif (MongoDB, ou
+     * PostgreSQL avec PostgREST désactivé), listings storage, analytics notifications.
+     *
+     * Ce n'est pas un oubli du gateway : PostgREST ne rend que `Content-Range` (`0-4/*`), qui
+     * décrit les lignes **rendues**, jamais la limite appliquée. Mesuré en réel (PostgREST
+     * v12.2.3, `db-max-rows=5`, table de 10 lignes) : une requête `limit=50` rabattue à 5
+     * produit exactement le même en-tête qu'une table qui ne contient que 5 lignes. Émettre
+     * `per_page = limit demandé` serait donc faux précisément dans le cas de troncature que ce
+     * champ sert à détecter — le gateway s'abstient plutôt que de mentir.
+     *
+     * Sur ce chemin, le motif de détection qui FONCTIONNE est le comptage explicite :
+     * demandez `count: 'exact'` (`.count('exact')`) et comparez `data.length` à `meta.total`
+     * (`data.length < meta.total` ⇒ il reste des lignes) — mesuré : `{"total":10}` pour
+     * 5 lignes rendues. Sans `count`, `meta` vaut `{}` et **aucune** troncature n'est
+     * détectable côté client.
+     */
+    per_page?: number;
     /**
      * Curseur opaque de pagination keyset (voir `QueryBuilder.cursor()`, `@aurabase/db`).
      * SPÉCIFIQUE AURA-DB : n'est émis QUE sur le chemin aura-db natif (MongoDB, ou
@@ -197,8 +233,51 @@ interface MagicLinkRequest {
     redirect_url?: string;
 }
 interface OAuthSignInOptions {
+    /**
+     * URL d'atterrissage après la connexion (parité Supabase).
+     *
+     * **Connexion aboutie** — le navigateur est redirigé sur cette URL MÊME, augmentée du seul
+     * fragment `#access_token=…&refresh_token=…&expires_in=…&token_type=bearer&user=…`.
+     * Aucun segment n'est ajouté.
+     *
+     * **⚠️ EXCEPTION — utilisateur avec MFA actif** : la connexion n'est pas encore aboutie, il
+     * reste un défi à relever. L'atterrissage est alors le sous-chemin dédié
+     * `{redirectTo}/oauth/mfa#mfa_token=…` (et `{site_url}/oauth/mfa#mfa_token=…` si `redirectTo`
+     * est omise). C'est délibéré : `#mfa_token` n'est pas une session, et l'envoyer sur la page
+     * d'accueil de l'application y déposerait un jeton que rien n'attend. Votre application DOIT
+     * donc servir une page sur `{redirectTo}/oauth/mfa` : elle y lit `mfa_token` dans le
+     * fragment, demande le code TOTP, puis appelle `mfaVerify({ mfa_token, code })`.
+     * `detectSessionInUrl` reconnaît ce fragment et émet `MFA_CHALLENGE` avec `mfaToken`
+     * (aucune session n'est posée). Le sous-chemin reste sous l'origine et le préfixe de chemin
+     * validés : il n'échappe pas à l'allowlist.
+     *
+     * Contraintes (N25) :
+     * - elle doit figurer dans l'allowlist `redirect_urls` du projet — c'est l'URL
+     *   validée, et c'est exactement celle qui sera servie ;
+     * - elle ne doit PAS contenir de fragment (`#…`) : le fragment final porte les
+     *   jetons et une URL ne peut pas en avoir deux — le démarrage répond `400`.
+     *
+     * **Divergence Supabase assumée** : une `redirectTo` HORS allowlist fait échouer le
+     * démarrage (`400`). Supabase, lui, l'ignore en silence et retombe sur le Site URL.
+     * Aurabase préfère l'erreur explicite — une redirection silencieuse vers une autre
+     * destination que celle demandée est indétectable côté application.
+     *
+     * Omise, le retour se fait sur `{site_url du projet}/oauth/callback` (convention
+     * historique d'Aurabase, inchangée : `site_url` est une base, pas une page).
+     */
     redirectTo?: string;
     scopes?: string;
+    /**
+     * Paramètres d'expérience de connexion transmis au provider (`prompt`, `login_hint`,
+     * `display`, `ui_locales`, `max_age`, `acr_values`, `claims_locales`, `access_type`,
+     * `include_granted_scopes`, `hd`).
+     *
+     * Toute autre clé est **refusée** (`error.code === 'invalid_oauth_query_param'`),
+     * jamais transmise ni ignorée en silence : les paramètres du protocole (`state`,
+     * `nonce`, `client_id`, `scope`, `code_challenge`…) sont calculés par le serveur, et
+     * ceux de la requête (`project_id`, `redirect_uri`, `scopes`) ont leur option dédiée.
+     * Le backend applique le même contrat et répond `400` — cf. `signInWithOAuth`.
+     */
     queryParams?: Record<string, string>;
     /**
      * Active le flux PKCE (génère + stocke un `code_verifier`, envoie
@@ -213,8 +292,16 @@ interface PasswordResetRequest {
     email: string;
 }
 interface UpdateUserRequest {
+    /**
+     * Nouvelle adresse email.
+     *
+     * **Ne change PAS l'email immédiatement** (A24) : le serveur envoie un lien de
+     * confirmation à la NOUVELLE adresse et répond `200` avec l'utilisateur **inchangé**
+     * — l'ancien email est donc normal dans la réponse. Le changement ne prend effet
+     * qu'une fois le lien suivi, via `verifyOtp({ type: 'email_change', token })`.
+     * Tant que la confirmation n'a pas eu lieu, `user.email` reste l'ancienne valeur.
+     */
     email?: string;
-    phone?: string;
     password?: string;
     current_password?: string;
     data?: Record<string, unknown>;
@@ -297,6 +384,146 @@ interface SchemaEnum {
     name: string;
     values: string[];
 }
+/**
+ * Rôles acceptés dans `grant_execute_to` à la CRÉATION d'une fonction.
+ *
+ * Miroir exact de l'allowlist backend `ALLOWED_ROLES` (`format_target_roles`,
+ * `services/aura-db/src/handlers/schema.rs`) : toute autre valeur est refusée en 400 —
+ * y compris `PUBLIC` et le rôle propriétaire `tenant_<uuid>` que la LECTURE
+ * (`PgFunctionInfo.grant_execute_to`) peut pourtant rendre. Union fermée à dessein :
+ * une faute de frappe se voit à la compilation plutôt qu'en 400 à l'exécution.
+ */
+type PgExecutableRole = 'anon' | 'authenticated' | 'service_role' | 'aura_anon' | 'aura_authenticated' | 'aura_service_role';
+/**
+ * Corps de `POST /v1/db/functions` — miroir de `CreateFunctionRequest`.
+ *
+ * Les défauts de sécurité du backend sont documentés champ par champ ci-dessous : ils
+ * sont SÛRS (aucune élévation, aucun droit d'exécution) tant qu'on ne les change pas.
+ */
+interface CreatePgFunctionRequest {
+    /**
+     * Nom de la fonction, pris TEL QUEL (la casse est conservée : le DDL le pose entre
+     * guillemets). Le backend REFUSE — il n'assainit pas en silence — tout nom qui n'est
+     * pas `[A-Za-z0-9_]+` : `calc-total` rend 400, il ne devient pas `calctotal`.
+     */
+    name: string;
+    /**
+     * Arguments, dans l'ordre. Même forme que ceux rendus par `GET /schema`
+     * (`SchemaFunctionArg`) — le backend désérialise les deux depuis la MÊME structure Rust
+     * `FunctionArg { name, data_type, mode }`.
+     *
+     * Les trois champs sont REQUIS (aucun `serde(default)` côté serveur : un `mode` absent
+     * fait échouer la désérialisation). `mode` doit valoir `'IN'` — le seul mode accepté à
+     * la création aujourd'hui ; `OUT`/`INOUT`/`VARIADIC` se lisent mais ne s'écrivent pas.
+     * `data_type` passe par une ALLOWLIST de formes (`text`, `uuid[]`, `numeric(10,2)`,
+     * `timestamp with time zone`…), pas par une denylist.
+     */
+    args: SchemaFunctionArg[];
+    /** Type de retour, même allowlist que `args[].data_type`, `setof x` compris. */
+    returns: string;
+    /** `plv8` n'est jamais installé : le backend n'accepte que ces deux langages. */
+    language: 'plpgsql' | 'sql';
+    /**
+     * Corps de la fonction. Soumis à la MÊME denylist d'isolation multi-tenant que
+     * `sql()` (cf. son docstring), en version PLUS stricte : ni `EXECUTE` (SQL dynamique),
+     * ni bascule de RLS — un corps est persistant et potentiellement GRANTable à `anon`.
+     */
+    body: string;
+    /**
+     * ⚠️ Défaut SÛR : `'invoker'` quand le champ est omis — la fonction s'exécute avec les
+     * droits de son APPELANT, aucune élévation de privilège implicite. `'definer'` la fait
+     * tourner avec ceux de son propriétaire (rôle admin du tenant) : à ne poser qu'en
+     * connaissance de cause. La casse est repliée côté serveur.
+     */
+    security?: 'invoker' | 'definer';
+    /**
+     * ⚠️ Défaut SÛR : AUCUN GRANT quand le champ est omis. Postgres accorde `EXECUTE` à
+     * `PUBLIC` sur toute fonction neuve (piège connu) ; le backend le RÉVOQUE
+     * systématiquement, de `PUBLIC` comme de tous les rôles de l'allowlist, AVANT
+     * d'appliquer ce champ. Une fonction créée sans `grant_execute_to` existe donc mais
+     * n'est appelable par personne — pas même en `rpc()` — tant qu'un GRANT explicite
+     * n'est pas posé. C'est voulu : un `CREATE OR REPLACE` qui RESTREINT restreint
+     * réellement, il n'hérite pas des droits de la version précédente.
+     */
+    grant_execute_to?: PgExecutableRole[];
+}
+/**
+ * Une fonction du schéma du projet, telle que la rend `GET /v1/db/functions`
+ * — miroir de `FunctionInfo`.
+ *
+ * Les quatre premiers champs sont historiques ; `args`, `security` et `grant_execute_to`
+ * ont été ajoutés côté serveur (la liste taisait jusque-là ce que la création écrivait
+ * pourtant réellement).
+ */
+interface PgFunctionInfo {
+    name: string;
+    /** Type de retour CANONIQUE Postgres : `text`, `text[]`, `SETOF uuid`, `TABLE(x integer)`. */
+    return_type: string;
+    /** Langage en MAJUSCULES, tel que le rend le catalogue (`SQL`, `PLPGSQL`). */
+    language: string;
+    /** Corps de la fonction. */
+    body: string;
+    /** `[]` si la fonction n'a aucun argument. `name` peut être vide (argument anonyme). */
+    args: SchemaFunctionArg[];
+    /**
+     * `'INVOKER'` ou `'DEFINER'` — MAJUSCULES à la lecture, alors que l'écriture attend des
+     * minuscules. Typé `string` et non une union fermée : c'est une valeur de fil, un
+     * affichage ne doit pas se croire exhaustif.
+     */
+    security: string;
+    /**
+     * Rôles portant `EXECUTE`, triés. Peut contenir `'PUBLIC'` et le rôle propriétaire
+     * (`tenant_<uuid>`), que Postgres matérialise dans l'ACL.
+     *
+     * ⚠️ LECTURE D'AUDIT UNIQUEMENT — ces valeurs ne sont PAS valides en écriture (cf.
+     * `PgExecutableRole`). Ne jamais les réinjecter telles quelles dans un
+     * `createFunction()`.
+     */
+    grant_execute_to: string[];
+}
+/**
+ * Corps de `POST /v1/db/:table/triggers` — miroir de `CreateTriggerRequest`.
+ *
+ * Le trigger BRANCHE une fonction déjà créée (`createFunction()` avec
+ * `returns: 'trigger'`) ; il n'en crée aucune. Les trois identifiants (`name`,
+ * `function_name`, et la table) sont pris tels quels ou refusés — jamais assainis en
+ * silence.
+ */
+interface CreatePgTriggerRequest {
+    name: string;
+    timing: 'before' | 'after' | 'instead_of';
+    /**
+     * Au moins un événement, sans DOUBLON (le backend refuse `['insert','insert']` — que
+     * Postgres rejetterait de toute façon). `truncate` exige `for_each: 'statement'`.
+     */
+    events: Array<'insert' | 'update' | 'delete' | 'truncate'>;
+    /** Fonction du MÊME schéma, appelée sans argument (`EXECUTE FUNCTION fn()`). */
+    function_name: string;
+    for_each: 'row' | 'statement';
+}
+/**
+ * Un trigger tel que le rend `GET /v1/db/:table/triggers`.
+ *
+ * ⚠️ La source est `information_schema.triggers`, qui rend UNE LIGNE PAR ÉVÉNEMENT : un
+ * trigger déclaré `INSERT OR UPDATE` ressort en DEUX entrées de même `name`, l'une avec
+ * `events: 'INSERT'`, l'autre `'UPDATE'`. Regrouper par `name` si l'affichage doit
+ * refléter le trigger et non ses événements.
+ */
+interface PgTriggerInfo {
+    name: string;
+    table_name: string;
+    /** `'BEFORE'`, `'AFTER'` ou `'INSTEAD OF'` — MAJUSCULES, contrairement à l'écriture. */
+    timing: string;
+    /** UN SEUL événement par entrée (`'INSERT'`, `'UPDATE'`, …) — voir la note ci-dessus. */
+    events: string;
+    /**
+     * ⚠️ Ce n'est PAS un nom de fonction mais l'`action_statement` complet du catalogue,
+     * p. ex. `EXECUTE FUNCTION project_xxx.set_updated_at()`. Le nom d'alias vient du
+     * serveur ; il est conservé tel quel plutôt que corrigé côté client, pour que ce type
+     * reste un miroir exact de la réponse.
+     */
+    function_name: string;
+}
 /**
  * Options de transformation d'image (vocabulaire façon Supabase) appliquées
  * côté rendu backend (`GET /v1/storage/{pid}/{bucket}/{key}?width=&height=&
@@ -353,7 +580,19 @@ interface FileEntry {
     content_type: string;
     etag?: string | null;
     last_modified?: string | null;
-    metadata: Record<string, unknown>;
+    /**
+     * ⚠️ TOUJOURS `{}` sur le retour de `list()` (C1).
+     *
+     * `ListObjectsV2` ne renvoie pas les métadonnées d'objet : le backend pose un objet vide
+     * (`storage/s3.rs`) et n'enrichit ensuite que `content_type` depuis la base
+     * (`handlers/manage.rs`). Le champ était déclaré NON optionnel, ce qui laissait écrire
+     * `files.find(f => f.metadata.owner === 'x')` — une recherche qui ne matche jamais, sans
+     * erreur ni erreur de type.
+     *
+     * Pour lire les métadonnées réelles d'un objet, appelez `getMetadata(bucket, key)`, qui
+     * fait un `HEAD` et les renvoie peuplées.
+     */
+    metadata?: Record<string, unknown>;
 }
 /** Métadonnées d'un objet storage — forme réelle retournée par getMetadata() */
 interface ObjectMeta {
@@ -386,9 +625,20 @@ interface ServerEventMsg {
 interface ServerPongMsg {
     type: 'pong';
 }
+/**
+ * Erreur serveur.
+ *
+ * `channel` (B9) distingue une erreur PROPRE À UN CANAL d'une erreur GLOBALE de session :
+ * - présent → l'erreur ne concerne QUE ce canal (refus RLS/write policy, canal hors projet,
+ *   quota de canaux, join/s, présence sans abonnement, retard de messages). Le SDK ne
+ *   notifie que lui ; si le canal est inconnu du client, personne n'est notifié.
+ * - absent  → erreur globale (heartbeat, token de session, message illisible, quota de
+ *   violations) : tous les canaux sont légitimement concernés.
+ */
 interface ServerErrorMsg {
     type: 'error';
     message: string;
+    channel?: string;
 }
 interface ServerTokenRefreshedMsg {
     type: 'token_refreshed';
@@ -480,6 +730,40 @@ interface PostgresChangesFilter {
 interface BroadcastFilter {
     event: string;
 }
+/**
+ * Résultat de `AuraChannel.send()` — un statut TYPÉ par cause.
+ *
+ * Avant C18/N24, trois échecs sans rapport partageaient la même valeur `'error'` :
+ * l'appelant ne pouvait ni les distinguer ni réagir différemment. Chaque cause a
+ * désormais son propre code, exhaustivement vérifiable par TypeScript.
+ *
+ * - `'ok'`
+ *   — sans `ack` : le message a été **remis au transport** (aucune confirmation
+ *     serveur n'est demandée dans ce mode) ;
+ *   — avec `ack` : le serveur a répondu `broadcast_ack` (confirmation de bout en bout).
+ * - `'timeout'` — `ack` demandé sur un canal abonné, mais aucun `broadcast_ack` reçu
+ *   dans les 5 s. Le message est parti ; c'est la réponse qui manque (lien coupé, accusé
+ *   perdu, serveur saturé). Ce statut ne recouvre QUE cette cause : le cas « le serveur a
+ *   refusé l'écriture faute d'abonnement » se résout désormais tout de suite en
+ *   `'requires_subscription'` (C18), au lieu d'être maquillé en attente expirée.
+ * - `'not_connected'` — le message n'a **pas quitté le process** : aucun transport lié
+ *   (canal jamais connecté) ou socket non-OPEN (`RealtimeService._send` jette
+ *   silencieusement ce qu'il ne peut pas émettre). À retenter après reconnexion.
+ * - `'requires_subscription'` — le SERVEUR n'a **pas d'abonnement** pour ce canal : rien
+ *   n'a été émis. Trois chemins y mènent :
+ *   1. `.subscribe()` n'a jamais été appelé ;
+ *   2. il a été appelé mais le serveur l'a **refusé** (`Accès refusé au canal privé (RLS
+ *      policy)`, `private_only`, quota de canaux…) — le canal a alors reçu `CHANNEL_ERROR` ;
+ *   3. l'abonnement a été **révoqué** ensuite (`Accès révoqué au channel '…' après token
+ *      refresh`), ou le serveur a répondu `Non abonné au canal '…'` à une écriture.
+ *   Le serveur exige l'abonnement avant toute écriture (`handlers/websocket.rs`, bras
+ *   `ClientMessage::Broadcast` : sans entrée d'abonnement, aucune policy RLS n'est
+ *   consultable pour ce canal — laisser passer serait fail-open). C'est le modèle de
+ *   Phoenix, dont dérive le protocole Supabase Realtime : on rejoint un topic avant d'y
+ *   pousser quoi que ce soit. Appelez `.subscribe()` — et vérifiez le statut qu'il rend.
+ * - `'error'` — l'envoi lui-même a levé une exception (sérialisation, transport).
+ */
+type BroadcastSendStatus = 'ok' | 'timeout' | 'not_connected' | 'requires_subscription' | 'error';
 /** Config pour presence */
 interface PresenceFilter {
     event: 'sync' | 'join' | 'leave';
@@ -489,17 +773,37 @@ interface ChannelConfig {
     private?: boolean;
     /** Configuration broadcast pour ce channel */
     broadcast?: {
-        /** Si true, le serveur ACK chaque send() (résout la Promise) */
+        /**
+         * Si `true`, le serveur accuse réception (`broadcast_ack`) des `send()` émis sur ce
+         * canal **une fois qu'il est abonné**, et `send()` ne résout qu'à cet accusé.
+         *
+         * **Prérequis — `.subscribe()` d'abord.** L'option `ack` voyage dans le message
+         * `subscribe` (`SubscribeConfig.broadcast.ack`) et le serveur ne la relit que dans la
+         * subscription de la connexion (`handlers/websocket.rs`, bras `Broadcast` :
+         * `subscriptions.get(&channel)` → `entry.config.broadcast.ack`). Sans abonnement, il
+         * n'a aucune config à consulter et **n'émettra jamais** d'accusé : `send()` sort donc
+         * immédiatement en `'requires_subscription'`, sans rien émettre ni attendre en vain
+         * (cf. {@link BroadcastSendStatus}).
+         */
         ack?: boolean;
         /** Si true, le client reçoit ses propres broadcasts (self-echo) */
         self?: boolean;
     };
-    /** Configuration présence */
+    /** Configuration présence directe */
+    presence?: {
+        /** Clé de présence — permet de regrouper plusieurs onglets/devices du même user */
+        key?: string;
+    };
+    /** Configuration compatible Supabase sous `config` */
     config?: {
+        broadcast?: {
+            ack?: boolean;
+            self?: boolean;
+        };
         presence?: {
-            /** Clé de présence — permet de regrouper plusieurs onglets/devices du même user */
             key?: string;
         };
+        private?: boolean;
     };
 }
 /** Payload d'un broadcast à envoyer */
@@ -528,6 +832,31 @@ interface ChatResponse {
     content: string;
     input_tokens?: number;
     output_tokens?: number;
+    /**
+     * Part des tokens de sortie consommée par le raisonnement du modèle
+     * (sous-ensemble d'`output_tokens`). Absent si le provider ne la rapporte pas.
+     */
+    reasoning_tokens?: number;
+    /**
+     * Motif d'arrêt NORMALISÉ par le serveur : `'stop' | 'length' | 'content_filter' |
+     * 'tool_use' | 'other'`.
+     *
+     * **A25** — sans lui, une réponse coupée par `max_tokens` (`'length'`) est indiscernable
+     * d'une réponse complète (`'stop'`) : le texte arrive tronqué, sans erreur ni signal. Le
+     * serveur le calcule et le renvoie déjà (`services/aura-ai/src/handlers/chat.rs`), et le
+     * chemin streamé le typait ; seul `chat()` le masquait.
+     *
+     * Le champ reste optionnel : un provider qui ne rapporte pas de motif, ou un serveur
+     * antérieur, renverra `undefined`.
+     */
+    finish_reason?: string;
+    /** Provider ayant effectivement répondu (`'openai'`, `'anthropic'`, `'google'`…). */
+    provider?: string;
+    /**
+     * `true` si une bascule de fallback a eu lieu — le provider effectif n'est pas celui
+     * demandé. Permet de tracer une dégradation silencieuse de qualité ou de coût.
+     */
+    fallback_used?: boolean;
 }
 interface EmbedRequest {
     text: string;
@@ -639,10 +968,30 @@ interface Notification {
 }
 interface SendNotificationRequest {
     channel: 'email' | 'sms' | 'push' | 'webhook';
+    /** Adresse email, numéro E.164, jeton d'appareil ou URL `https://`, selon le canal. */
     recipient: string;
+    /** Corps du message. Ignoré quand `template_id` est fourni. */
     body?: string;
+    /**
+     * ⚠️ Sémantique dépendante du canal (A28) — ce n'est pas partout un « sujet » :
+     * - `email`   → en-tête `Subject` du message. Absent ⇒ `"Notification Aurabase"` ;
+     * - `push`    → **titre** de la notification affichée. Absent ⇒ `"Notification"` ;
+     * - `webhook` → champ **`"event"`** du corps JSON POSTé. Absent ⇒ `"notification"` ; il
+     *               participe en outre à la clé d'idempotence de livraison ;
+     * - `sms`     → **ignoré** (Twilio ne reçoit que `To`, `From` et `Body`).
+     *
+     * Avec `template_id` : à la différence de `body`, ce champ n'est PAS ignoré — un sujet non
+     * vide **surcharge** celui du template et est interpolé avec les mêmes `variables` ; vide ou
+     * absent, le sujet du template s'applique.
+     */
     subject?: string;
+    /** Le `body` fourni est ignoré : c'est le corps du template qui est rendu. */
     template_id?: string;
+    /**
+     * Valeurs interpolées dans `body`/`subject` (`{{ var }}`), avec ou sans `template_id`.
+     * Une variable manquante refuse l'envoi (400). Les variables se fournissent ICI, jamais
+     * en déclaration sur le template.
+     */
     variables?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
     idempotency_key?: string;
@@ -658,11 +1007,30 @@ interface BatchSendResponse {
 }
 interface NotificationTemplate {
     id: string;
+    /**
+     * N53 — le serveur renvoie ce champ sur TOUTES les routes template (`POST /templates`,
+     * `GET /templates`, `GET /templates/{id}`, `PATCH /templates/{id}`) : il est sérialisé
+     * depuis `NotificationTemplate` côté Rust. Il manquait ici — miroir exact de C24, où un
+     * champ DÉCLARÉ (`variables`) n'existait pas côté serveur ; ici un champ qui EXISTE
+     * n'était pas déclaré, donc invisible aux appelants typés.
+     */
+    project_id: string;
     name: string;
+    /**
+     * Le canal est FIXÉ à la création : il conditionne le rendu (échappement HTML pour
+     * `email`, texte brut sinon) et la validation à l'envoi. Le serveur refuse de le modifier
+     * (400) — créez un autre template pour un autre canal.
+     */
     channel: 'email' | 'sms' | 'push' | 'webhook';
+    /**
+     * ⚠️ Sémantique dépendante du canal (A28) :
+     * - `email`   → en-tête Subject du message ;
+     * - `push`    → **titre** de la notification ;
+     * - `webhook` → champ **`"event"`** du corps JSON envoyé au destinataire ;
+     * - `sms`     → **ignoré** (un SMS n'a pas de sujet).
+     */
     subject?: string | null;
     body: string;
-    variables?: string[];
     created_at: string;
     updated_at: string;
 }
@@ -841,7 +1209,6 @@ interface AuraClientOptions {
          */
         detectSessionInUrl?: boolean;
     };
-    apiKey?: string;
     fetch?: typeof globalThis.fetch;
     /**
      * SEC-F5 : si une clé `service_role` (`aura_sk_…`) est fournie en contexte NAVIGATEUR
@@ -885,8 +1252,7 @@ interface IdentityInfo {
     auto_linked: boolean;
     created_at: string;
 }
-interface AdminUser extends User {
-}
+type AdminUser = User;
 interface AuditLogEntry {
     id: string;
     user_id?: string | null;
@@ -916,6 +1282,24 @@ interface AdminSessionInfo {
     expires_at: string;
     last_used_at: string;
 }
+/**
+ * Valeur d'un provider dans `oauth_providers`.
+ *
+ * Le backend stocke ce champ en JSONB libre et l'interprète de DEUX façons :
+ *  - un booléen — simple interrupteur (défaut du schéma : `{"github": true, "google": true}`) ;
+ *  - un objet de configuration — `client_id`/`client_secret`/`scopes` pour un provider intégré,
+ *    ou `discovery_url`+`client_id`+`client_secret` sous une clé `oidc:<nom>` pour un OIDC
+ *    personnalisé (cf. `load_oidc_config`, services/aura-auth/src/handlers/oauth.rs).
+ */
+type OAuthProviderSetting = boolean | {
+    enabled?: boolean;
+    client_id?: string;
+    client_secret?: string;
+    scopes?: string[];
+    /** OIDC personnalisé (clé `oidc:<nom>`) : endpoint de découverte OpenID Connect. */
+    discovery_url?: string;
+    [key: string]: unknown;
+};
 interface AuthSettings {
     allow_signup: boolean;
     email_confirmation_required: boolean;
@@ -925,11 +1309,7 @@ interface AuthSettings {
     jwt_expiry_seconds: number;
     refresh_token_expiry_days: number;
     site_url?: string | null;
-    oauth_providers: Record<string, {
-        enabled?: boolean;
-        client_id?: string;
-        client_secret?: string;
-    }>;
+    oauth_providers: Record<string, OAuthProviderSetting>;
     new_device_alerts_enabled: boolean;
     webhook_url?: string | null;
     smtp_host?: string | null;
@@ -953,13 +1333,142 @@ interface AuthSettings {
     hook_send_email_url?: string | null;
     hook_mfa_verification_url?: string | null;
     hook_password_verification_url?: string | null;
+    /** Hook BLOQUANT avant inscription : peut refuser le signup. */
+    hook_before_signup_url?: string | null;
+    /** Hook de notification après inscription (fire-and-forget). */
+    hook_after_signup_url?: string | null;
+    /** Hook d'enrichissement des claims du JWT à chaque émission de jeton. */
+    hook_custom_access_token_url?: string | null;
+    /**
+     * Le secret HMAC qui SIGNE tous les hooks est posé (write-only : jamais relu en clair).
+     * Sans lui, aucun hook n'est signé — le destinataire ne peut pas authentifier l'appel.
+     */
+    hook_secret_set?: boolean;
     auto_link_by_email: boolean;
+    password_require_uppercase: boolean;
+    password_require_number: boolean;
+    password_require_special: boolean;
     revoke_on_new_device: boolean;
     enforce_ip_binding: boolean;
     allowed_email_domains: string[];
     blocked_email_domains: string[];
+    rate_limit_login_per_hour: number;
+    rate_limit_emails_per_hour: number;
+    rate_limit_signup_per_hour: number;
     updated_at: string;
 }
+/**
+ * Champs RÉELLEMENT acceptés en écriture par `PUT /v1/auth/{project_id}/admin/settings`.
+ *
+ * Miroir exact de `UpdateSettingsRequest` (services/aura-auth/src/handlers/settings.rs) —
+ * un test anti-divergence relit la struct Rust et compare. Ne PAS y ajouter un champ que
+ * le backend ne désérialise pas : `UpdateSettingsRequest` porte `deny_unknown_fields`,
+ * l'appel entier serait REFUSÉ (`400`, le champ fautif est nommé).
+ */
+declare const AUTH_SETTINGS_WRITABLE_FIELDS: readonly ["allow_signup", "email_confirmation_required", "password_min_length", "mfa_enabled", "allow_anonymous_users", "jwt_expiry_seconds", "refresh_token_expiry_days", "site_url", "oauth_providers", "new_device_alerts_enabled", "webhook_url", "webhook_secret", "smtp_host", "smtp_port", "smtp_username", "smtp_password", "smtp_from_email", "smtp_from_name", "smtp_clear", "oauth_credentials", "oauth_credentials_clear", "captcha_enabled", "captcha_provider", "captcha_site_key", "captcha_secret_key", "password_check_hibp", "sms_provider", "sms_api_key", "sms_api_secret", "sms_from_number", "sms_clear", "redirect_urls", "session_inactivity_timeout_seconds", "hook_send_sms_url", "hook_send_email_url", "hook_mfa_verification_url", "hook_password_verification_url", "auto_link_by_email", "rate_limit_login_per_hour", "rate_limit_emails_per_hour", "rate_limit_signup_per_hour", "revoke_on_new_device", "enforce_ip_binding", "allowed_email_domains", "blocked_email_domains", "password_require_uppercase", "password_require_number", "password_require_special", "hook_before_signup_url", "hook_after_signup_url", "hook_custom_access_token_url", "hook_secret"];
+/**
+ * Corps de `authAdmin.updateSettings()`.
+ *
+ * Distinct de `Partial<AuthSettings>` À DESSEIN, dans les deux sens :
+ *  - il AJOUTE les champs write-only que la vue de lecture ne peut pas porter (secrets
+ *    `webhook_secret`/`smtp_password`/`captcha_secret_key`/`sms_api_key`/`sms_api_secret`,
+ *    drapeaux d'effacement `smtp_clear`/`sms_clear`/`oauth_credentials_clear`,
+ *    `oauth_credentials` en clair) ;
+ *  - il RETIRE les projections de lecture (`smtp_password_set`, `captcha_secret_key_set`,
+ *    `sms_api_key_set`, `hook_secret_set`, `updated_at`) : le backend les REFUSE.
+ *
+ * Ces deux refus sont ceux du SERVEUR, pas seulement du compilateur (C26, rectifié) :
+ *  - champ inconnu → `400` nommant le champ (`deny_unknown_fields` sur `UpdateSettingsRequest`) ;
+ *  - `null` explicite → `400` : la mise à jour est un `COALESCE($n, colonne)`, donc `null`
+ *    ne remet RIEN à zéro — il ne ferait rien. Pour effacer, utiliser les drapeaux `*_clear`
+ *    (SMTP/SMS/OAuth) ou la valeur vide (`""`, `[]`) selon le champ.
+ *
+ * Conséquence pratique : ne PAS renvoyer tel quel un objet lu par `getSettings()`
+ * (`{...settings, mfa_enabled: true}`) — il porte `updated_at` et les `*_set`, l'appel serait
+ * refusé. N'envoyez que les champs à modifier.
+ */
+interface AuthSettingsUpdate {
+    allow_signup?: boolean;
+    email_confirmation_required?: boolean;
+    /** Entre 8 et 128 (refusé hors bornes par le backend). */
+    password_min_length?: number;
+    mfa_enabled?: boolean;
+    allow_anonymous_users?: boolean;
+    /** Entre 300 et 3600 secondes. */
+    jwt_expiry_seconds?: number;
+    /** Entre 1 et 90 jours. */
+    refresh_token_expiry_days?: number;
+    site_url?: string;
+    oauth_providers?: Record<string, OAuthProviderSetting>;
+    new_device_alerts_enabled?: boolean;
+    webhook_url?: string;
+    /** Write-only : jamais relu par `getSettings()`. */
+    webhook_secret?: string;
+    smtp_host?: string;
+    smtp_port?: number;
+    smtp_username?: string;
+    /** Write-only ; `getSettings()` n'expose que `smtp_password_set`. */
+    smtp_password?: string;
+    smtp_from_email?: string;
+    smtp_from_name?: string;
+    /** `true` = efface TOUTE la config SMTP du projet (retour au SMTP global). */
+    smtp_clear?: boolean;
+    /** Fusion partielle ; `getSettings()` ne les renvoie que MASQUÉS. */
+    oauth_credentials?: Record<string, Record<string, unknown>>;
+    /** `true` = efface tous les identifiants OAuth du projet (retour aux variables globales). */
+    oauth_credentials_clear?: boolean;
+    captcha_enabled?: boolean;
+    captcha_provider?: string;
+    captcha_site_key?: string;
+    /** Write-only ; `getSettings()` n'expose que `captcha_secret_key_set`. */
+    captcha_secret_key?: string;
+    password_check_hibp?: boolean;
+    sms_provider?: string;
+    /** Write-only ; `getSettings()` n'expose que `sms_api_key_set`. */
+    sms_api_key?: string;
+    /** Write-only : jamais relu. */
+    sms_api_secret?: string;
+    sms_from_number?: string;
+    /** `true` = efface toute la config SMS. */
+    sms_clear?: boolean;
+    redirect_urls?: string[];
+    /** 0 (désactivé) ou >= 300 secondes. */
+    session_inactivity_timeout_seconds?: number;
+    hook_send_sms_url?: string;
+    hook_send_email_url?: string;
+    hook_mfa_verification_url?: string;
+    hook_password_verification_url?: string;
+    /** Hook BLOQUANT avant inscription : un refus du hook annule le signup. */
+    hook_before_signup_url?: string;
+    /** Hook de notification après inscription (fire-and-forget). */
+    hook_after_signup_url?: string;
+    /** Hook d'enrichissement des claims du JWT (fusionnés dans `app_metadata`). */
+    hook_custom_access_token_url?: string;
+    /**
+     * Secret HMAC signant TOUS les hooks (en-tête `X-Aurabase-Signature`).
+     *
+     * Write-only ; `getSettings()` n'expose que `hook_secret_set`. Tant qu'il est absent,
+     * les hooks partent NON SIGNÉS : le destinataire ne peut pas distinguer un appel
+     * Aurabase d'un appel forgé par un tiers.
+     */
+    hook_secret?: string;
+    auto_link_by_email?: boolean;
+    /** Exige au moins une majuscule (inscription + changement de mot de passe). */
+    password_require_uppercase?: boolean;
+    /** Exige au moins un chiffre. */
+    password_require_number?: boolean;
+    /** Exige au moins un caractère spécial. */
+    password_require_special?: boolean;
+    rate_limit_login_per_hour?: number;
+    rate_limit_emails_per_hour?: number;
+    rate_limit_signup_per_hour?: number;
+    revoke_on_new_device?: boolean;
+    enforce_ip_binding?: boolean;
+    /** Remplacement complet (sémantique de liste, pas de fusion). */
+    allowed_email_domains?: string[];
+    /** Remplacement complet. */
+    blocked_email_domains?: string[];
+}
 interface EmailTemplateUpdate {
     subject: string;
     html_body: string;
@@ -1068,8 +1577,12 @@ declare class BaseAuthStore {
  * dépendance core → meta (les services n'importent plus la classe concrète).
  */
 interface AuraClientLike {
+    /**
+     * URL du projet (`https://<slug>.aurabase.cloud`). C'est elle — et elle seule — qui
+     * désigne le projet : la passerelle résout le tenant depuis l'hôte et injecte le
+     * `project_id` dans le chemin. Aucun identifiant de projet ne transite côté client.
+     */
     readonly baseUrl: string;
-    readonly projectId: string;
     readonly apiKey: string | null;
     readonly fetchFn: typeof globalThis.fetch;
     readonly authStore: BaseAuthStore;
@@ -1098,6 +1611,42 @@ interface AuraClientLike {
     readonly debug?: boolean;
 }
 
+/**
+ * Abstract base class for all service modules.
+ * Provides the shared HTTP helper and URL builder.
+ */
+declare abstract class BaseService {
+    protected readonly client: AuraClientLike;
+    constructor(client: AuraClientLike);
+    /** Build a full URL for the given path. */
+    protected url(path: string): string;
+    /** Convenience HTTP helper that delegates to fetchWithAuth. */
+    protected request<T>(method: string, path: string, body?: unknown, options?: {
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+        skipAuthRefresh?: boolean;
+        /** Override explicite du Bearer (LOT D) — valide un token arbitraire. */
+        authToken?: string;
+    }): Promise<AuraResponse<T>>;
+}
+
+/**
+ * Parse a raw Cookie header string into key-value pairs.
+ */
+declare function parseCookieHeader(header: string): Record<string, string>;
+interface SerializeCookieOptions {
+    path?: string;
+    domain?: string;
+    maxAge?: number;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    httpOnly?: boolean;
+}
+/**
+ * Serialize a cookie name + value + options into a Set-Cookie header value.
+ */
+declare function serializeCookieHeader(name: string, value: string, options?: SerializeCookieOptions): string;
+
 /** Timeout par défaut d'une requête HTTP (borne un serveur qui « hang »). */
 declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 /** Point d'entrée unique du refresh, dédupliqué par client (single-flight). */
@@ -1130,23 +1679,43 @@ interface FetchInit {
 declare function fetchWithAuth<T>(url: string, init: FetchInit, client: AuraClientLike): Promise<AuraResponse<T>>;
 
 /**
- * Abstract base class for all service modules.
- * Provides the shared HTTP helper and URL builder.
+ * Primitives de résilience réseau (module pur, sans I/O).
+ * `Math.random`/`Date.now` sont injectables pour des tests déterministes.
  */
-declare abstract class BaseService {
-    protected readonly client: AuraClientLike;
-    constructor(client: AuraClientLike);
-    /** Build a full URL for the given path. */
-    protected url(path: string): string;
-    /** Convenience HTTP helper that delegates to fetchWithAuth. */
-    protected request<T>(method: string, path: string, body?: unknown, options?: {
-        headers?: Record<string, string>;
-        signal?: AbortSignal;
-        skipAuthRefresh?: boolean;
-        /** Override explicite du Bearer (LOT D) — valide un token arbitraire. */
-        authToken?: string;
-    }): Promise<AuraResponse<T>>;
-}
+declare const RETRYABLE_STATUS: Set<number>;
+declare const RETRYABLE_METHODS: Set<string>;
+declare const DEFAULT_MAX_RETRIES = 3;
+declare function isRetryableStatus(status: number): boolean;
+declare function isRetryableMethod(method: string): boolean;
+/** Full jitter : random(0, min(BASE·2^attempt, CAP)). `attempt` commence à 0. */
+declare function computeBackoff(attempt: number, rand?: () => number): number;
+/** Parse un header `Retry-After` (secondes OU HTTP-date) → délai en ms, ou null. */
+declare function parseRetryAfter(header: string | null, now?: number): number | null;
+/** `sleep(ms)` qui résout tôt (sans rejeter) si `signal` s'annule. */
+declare function abortableSleep(ms: number, signal?: AbortSignal): Promise<void>;
+/** True si l'erreur `fetch` est une annulation utilisateur (jamais rejouée). */
+declare function isAbortError(err: unknown): boolean;
+
+/**
+ * Portée d'un client, dérivée de son URL de projet.
+ *
+ * Chaque projet est adressé par son PROPRE hôte (`https://<slug>.aurabase.cloud`), et le
+ * SDK ne connaît plus d'identifiant de projet : l'URL est la seule chose qui distingue
+ * deux projets. Tout ce qui devait auparavant être « scopé projet » côté client — clé
+ * BroadcastChannel de synchro multi-onglets, `code_verifier` PKCE, marqueur d'initiation
+ * OAuth, nom de cookie SSR, nom de verrou de refresh — se scope donc par cette portée.
+ *
+ * Ce n'est PAS cosmétique : une page (`app.example.com`) peut parfaitement instancier deux
+ * clients pointant sur deux projets. Sans portée, leurs clés de stockage se marcheraient
+ * dessus dans le MÊME `localStorage`, celui de la page.
+ *
+ * Le résultat est réduit à `[a-z0-9-]` : il sert aussi de nom de cookie, et un nom de
+ * cookie est un `token` RFC 6265 — un `:` de port (`localhost:8080`) y est interdit.
+ */
+declare function clientScope(baseUrl: string): string;
+
+/** JSON.stringify avec support des bigint (sérialisés en string). */
+declare function serializeBody(body: unknown): string;
 
 interface CookieOptions {
     path?: string;
@@ -1158,21 +1727,36 @@ interface CookieOptions {
 }
 /**
  * Auth store backed by `localStorage` (browser) with cookie helpers for SSR.
+ *
+ * `key` est OBLIGATOIRE, et c'est le correctif K3 : la session est le sixième état
+ * local du SDK, et le seul qui n'était pas scopé par projet. Un nom par défaut
+ * constant faisait que deux clients pointant sur deux projets dans la MÊME page
+ * écrivaient sous la même clé du MÊME `localStorage` (celui de la page, pas celui du
+ * projet) et s'écrasaient mutuellement. Le nom canonique est
+ * `aura-${clientScope(baseUrl)}-auth` — celui que posent `AuraClient` (navigateur) et
+ * `createServerClient` (cookie SSR), et la même convention que les cinq autres états
+ * (`aura-<portée>-pkce-code-verifier`, `-oauth-implicit-initiated`, canal de synchro,
+ * verrou de refresh). Voir `packages/core/src/scope.ts`.
  */
 declare class LocalAuthStore extends BaseAuthStore {
     /** Persiste en localStorage → survit au redirect pleine page (cf. PKCE). */
     readonly persistent = true;
     private readonly key;
-    constructor(key?: string);
+    /**
+     * @param key Nom de l'entrée `localStorage` (et du cookie SSR). Scopez-le par projet :
+     *            `aura-${clientScope(baseUrl)}-auth`.
+     */
+    constructor(key: string);
     save(token: string, refreshToken: string, user: User): void;
     clear(): void;
     /**
      * Supprime de localStorage tous les artefacts d'auth éphémères sur disque :
-     *  - `code_verifier` PKCE (`aura-<projectId>-pkce-code-verifier`),
-     *  - marqueur d'initiation OAuth implicit (`aura-<projectId>-oauth-implicit-initiated`,
+     *  - `code_verifier` PKCE (`aura-<portée>-pkce-code-verifier`),
+     *  - marqueur d'initiation OAuth implicit (`aura-<portée>-oauth-implicit-initiated`,
      *    SEC-F3). Un `signOut`/`clear()` ne doit laisser aucun résidu réutilisable (parité
      * `@supabase/ssr` : ces artefacts sont éphémères). On itère les clés préfixées pour
-     * couvrir un store partagé entre plusieurs projets, sans dépendre du `projectId` courant.
+     * couvrir un store partagé entre plusieurs projets, sans dépendre de la portée courante
+     * (`clientScope`, dérivée de l'URL du projet).
      */
     private _removePkceVerifiers;
     setItem(key: string, value: string): void;
@@ -1192,42 +1776,4 @@ declare class LocalAuthStore extends BaseAuthStore {
     private _removeStorage;
 }
 
-/** JSON.stringify avec support des bigint (sérialisés en string). */
-declare function serializeBody(body: unknown): string;
-
-/**
- * Parse a raw Cookie header string into key-value pairs.
- */
-declare function parseCookieHeader(header: string): Record<string, string>;
-interface SerializeCookieOptions {
-    path?: string;
-    domain?: string;
-    maxAge?: number;
-    secure?: boolean;
-    sameSite?: 'Strict' | 'Lax' | 'None';
-    httpOnly?: boolean;
-}
-/**
- * Serialize a cookie name + value + options into a Set-Cookie header value.
- */
-declare function serializeCookieHeader(name: string, value: string, options?: SerializeCookieOptions): string;
-
-/**
- * Primitives de résilience réseau (module pur, sans I/O).
- * `Math.random`/`Date.now` sont injectables pour des tests déterministes.
- */
-declare const RETRYABLE_STATUS: Set<number>;
-declare const RETRYABLE_METHODS: Set<string>;
-declare const DEFAULT_MAX_RETRIES = 3;
-declare function isRetryableStatus(status: number): boolean;
-declare function isRetryableMethod(method: string): boolean;
-/** Full jitter : random(0, min(BASE·2^attempt, CAP)). `attempt` commence à 0. */
-declare function computeBackoff(attempt: number, rand?: () => number): number;
-/** Parse un header `Retry-After` (secondes OU HTTP-date) → délai en ms, ou null. */
-declare function parseRetryAfter(header: string | null, now?: number): number | null;
-/** `sleep(ms)` qui résout tôt (sans rejeter) si `signal` s'annule. */
-declare function abortableSleep(ms: number, signal?: AbortSignal): Promise<void>;
-/** True si l'erreur `fetch` est une annulation utilisateur (jamais rejouée). */
-declare function isAbortError(err: unknown): boolean;
-
-export { type AdminCreateUserRequest, type AdminSessionInfo, type AdminUpdateUserRequest, type AdminUser, type AuditLogEntry, type AuraClientLike, type AuraClientOptions, AuraError, type AuraErrorCode, type AuraFailure, type AuraNoContent, type AuraObservabilityEvent, type AuraResponse, type AuraSuccess, type AuthChangePayload, type AuthEvent, type AuthSettings, BaseAuthStore, BaseService, type BatchSendItemResult, type BatchSendResponse, type BroadcastAckMessage, type BroadcastFilter, type BroadcastPayload, type CdcPayload, type ChannelConfig, type ChatMessage, type ChatResponse, type CountMode, type CronJob, DEFAULT_MAX_RETRIES, DEFAULT_REQUEST_TIMEOUT_MS, type EmailTemplateUpdate, type EmbedRequest, type EmbedResponse, type FetchInit, type FileEntry, type FilterOp, type FunctionDef, type GenerateLinkResult, type GenerateLinkType, type GetClaimsResult, type IdentityInfo, type ImageTransform, type Job, type JwtClaims, LocalAuthStore, type LoginResponse, type MagicLinkRequest, type Meta, type MfaChallenge, type MfaEnrollResponse, type MfaVerifyRequest, type Notification, type NotificationAttempt, type NotificationChannelStats, type NotificationDeadLetter, type NotificationEvent, type NotificationProviderLog, type NotificationQueueStats, type NotificationRule, type NotificationSettings, type NotificationStats, type NotificationTemplate, type NotificationTemplatePreview, type OAuthSignInOptions, type ObjectMeta, type PasswordResetRequest, type PostgresChangesFilter, type PresenceFilter, type PresenceInfo, type PresenceState, type QueryFilter, type QueryOptions, RETRYABLE_METHODS, RETRYABLE_STATUS, type RagIngestRequest, type RagIngestResponse, type RagRequest, type RagResponse, type RealtimeEvent, type RealtimeListenType, type RealtimeSubscribeStatus, type SchemaColumn, type SchemaEnum, type SchemaFunction, type SchemaFunctionArg, type SchemaIndex, type SchemaTable, type SemanticSearchResult, type SendNotificationRequest, type SerializeCookieOptions, type ServerErrorMsg, type ServerEventMsg, type ServerMessage, type ServerPongMsg, type ServerPresenceStateMsg, type ServerSubscribedMsg, type ServerTokenRefreshedMsg, type SessionInfo, type SignInRequest, type SignUpRequest, type StorageBucket, type SubscribeCallback, type TokenPair, type UpdateUserRequest, type UploadResult, type User, type UserStats, abortableSleep, computeBackoff, emitAuraEvent, fetchWithAuth, isAbortError, isAuraError, isRetryableMethod, isRetryableStatus, isTokenExpired, parseCookieHeader, parseRetryAfter, refreshOnce, serializeBody, serializeCookieHeader };
+export { AUTH_SETTINGS_WRITABLE_FIELDS, type AdminCreateUserRequest, type AdminSessionInfo, type AdminUpdateUserRequest, type AdminUser, type AuditLogEntry, type AuraClientLike, type AuraClientOptions, AuraError, type AuraErrorCode, type AuraFailure, type AuraNoContent, type AuraObservabilityEvent, type AuraResponse, type AuraSuccess, type AuthChangePayload, type AuthEvent, type AuthSettings, type AuthSettingsUpdate, BaseAuthStore, BaseService, type BatchSendItemResult, type BatchSendResponse, type BroadcastAckMessage, type BroadcastFilter, type BroadcastPayload, type BroadcastSendStatus, type CdcPayload, type ChannelConfig, type ChatMessage, type ChatResponse, type CountMode, type CreatePgFunctionRequest, type CreatePgTriggerRequest, type CronJob, DEFAULT_MAX_RETRIES, DEFAULT_REQUEST_TIMEOUT_MS, type EmailTemplateUpdate, type EmbedRequest, type EmbedResponse, type FetchInit, type FileEntry, type FilterOp, type FunctionDef, type GenerateLinkResult, type GenerateLinkType, type GetClaimsResult, type IdentityInfo, type ImageTransform, type Job, type JwtClaims, LocalAuthStore, type LoginResponse, type MagicLinkRequest, type Meta, type MfaChallenge, type MfaEnrollResponse, type MfaVerifyRequest, type Notification, type NotificationAttempt, type NotificationChannelStats, type NotificationDeadLetter, type NotificationEvent, type NotificationProviderLog, type NotificationQueueStats, type NotificationRule, type NotificationSettings, type NotificationStats, type NotificationTemplate, type NotificationTemplatePreview, type OAuthProviderSetting, type OAuthSignInOptions, type ObjectMeta, type PasswordResetRequest, type PgExecutableRole, type PgFunctionInfo, type PgTriggerInfo, type PostgresChangesFilter, type PresenceFilter, type PresenceInfo, type PresenceState, type QueryFilter, type QueryOptions, RETRYABLE_METHODS, RETRYABLE_STATUS, type RagIngestRequest, type RagIngestResponse, type RagRequest, type RagResponse, type RealtimeEvent, type RealtimeListenType, type RealtimeSubscribeStatus, type SchemaColumn, type SchemaEnum, type SchemaFunction, type SchemaFunctionArg, type SchemaIndex, type SchemaTable, type SemanticSearchResult, type SendNotificationRequest, type SerializeCookieOptions, type ServerErrorMsg, type ServerEventMsg, type ServerMessage, type ServerPongMsg, type ServerPresenceStateMsg, type ServerSubscribedMsg, type ServerTokenRefreshedMsg, type SessionInfo, type SignInRequest, type SignUpRequest, type StorageBucket, type SubscribeCallback, type TokenPair, type UpdateUserRequest, type UploadResult, type User, type UserStats, abortableSleep, clientScope, computeBackoff, emitAuraEvent, fetchWithAuth, isAbortError, isAuraError, isRetryableMethod, isRetryableStatus, isTokenExpired, parseCookieHeader, parseRetryAfter, refreshOnce, serializeBody, serializeCookieHeader };